{
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.12",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "sourceId": 7207717,
     "sourceType": "datasetVersion",
     "datasetId": 4170016
    }
   ],
   "dockerImageVersionId": 30627,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook",
   "isGpuEnabled": true
  }
 },
 "nbformat_minor": 4,
 "nbformat": 4,
 "cells": [
  {
   "cell_type": "code",
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n",
    "np.random.seed(seed)\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-15T03:59:34.073937500Z",
     "start_time": "2023-12-15T03:59:25.259518900Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-15T09:27:08.448546Z",
     "iopub.execute_input": "2023-12-15T09:27:08.449462Z",
     "iopub.status.idle": "2023-12-15T09:27:08.463004Z",
     "shell.execute_reply.started": "2023-12-15T09:27:08.449421Z",
     "shell.execute_reply": "2023-12-15T09:27:08.461813Z"
    },
    "trusted": true
   },
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "text": "sys.version_info(major=3, minor=10, micro=12, releaselevel='final', serial=0)\nmatplotlib 3.7.4\nnumpy 1.24.3\npandas 2.1.4\nsklearn 1.2.2\ntorch 2.0.0\ncuda:0\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 数据加载\n",
    "\n",
    "- 采用WMT16的德语和英语平行语料库，数据集主页：[WMT16](https://www.statmt.org/wmt16/multimodal-task.html#task1)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "# 这部分我们在本地完成\n",
    "# !pip install sacremoses\n",
    "# pip install subword-nmt\n",
    "# # BPE分词\n",
    "# !sh data_multi30k.sh wmt16 de en\n",
    "!ls"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-15T08:06:16.583879900Z",
     "start_time": "2023-12-15T08:05:47.946606900Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-15T09:27:08.620548Z",
     "iopub.execute_input": "2023-12-15T09:27:08.620948Z",
     "iopub.status.idle": "2023-12-15T09:27:09.599571Z",
     "shell.execute_reply.started": "2023-12-15T09:27:08.620918Z",
     "shell.execute_reply": "2023-12-15T09:27:09.598184Z"
    },
    "trusted": true
   },
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "Dataset"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "!ls ../input/wmt16-de-en"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:27:09.602204Z",
     "iopub.execute_input": "2023-12-15T09:27:09.602591Z",
     "iopub.status.idle": "2023-12-15T09:27:10.616949Z",
     "shell.execute_reply.started": "2023-12-15T09:27:09.602555Z",
     "shell.execute_reply": "2023-12-15T09:27:10.615693Z"
    },
    "trusted": true
   },
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "text": "bpe.10000\t  test_trg.bpe\t    train_src.bpe      val.en\t\tvocab\ntest.de\t\t  test_trg.cut.txt  train_src.cut.txt  val_src.bpe\ntest.en\t\t  train.de\t    train_trg.bpe      val_src.cut.txt\ntest_src.bpe\t  train.en\t    train_trg.cut.txt  val_trg.bpe\ntest_src.cut.txt  train_l\t    val.de\t       val_trg.cut.txt\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "from pathlib import Path\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "\n",
    "\n",
    "class LangPairDataset(Dataset):\n",
    "\n",
    "    def __init__(\n",
    "        self, mode=\"train\", max_length=128, overwrite_cache=False, data_dir=\"../input/wmt16-de-en\",\n",
    "    ):\n",
    "        self.data_dir = Path(data_dir)\n",
    "        cache_path = Path(\".cache/\" + f\"de2en_{mode}_{max_length}.npy\")\n",
    "\n",
    "        if overwrite_cache or not cache_path.exists():\n",
    "            cache_path.parent.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "            with open(self.data_dir / f\"{mode}_src.bpe\", \"r\", encoding=\"utf8\") as file:\n",
    "                self.src = file.readlines()\n",
    "\n",
    "            with open(self.data_dir / f\"{mode}_trg.bpe\", \"r\", encoding=\"utf8\") as file:\n",
    "                self.trg = file.readlines()\n",
    "\n",
    "            filtered_src = []\n",
    "            filtered_trg = []\n",
    "            # max length filter\n",
    "            for src, trg in zip(self.src, self.trg):\n",
    "                if len(src) <= max_length and len(trg) <= max_length:\n",
    "                    filtered_src.append(src.strip())\n",
    "                    filtered_trg.append(trg.strip())\n",
    "\n",
    "            np.save(\n",
    "                cache_path,\n",
    "                {\"src\": np.array(filtered_src), \"trg\": np.array(filtered_trg)},\n",
    "                allow_pickle=True,\n",
    "            )\n",
    "            print(f\"save cache to {cache_path}\")\n",
    "\n",
    "        else:\n",
    "            cache_dict = np.load(cache_path, allow_pickle=True).item()\n",
    "            print(f\"load {mode} dataset from {cache_path}\")\n",
    "            filtered_src = cache_dict[\"src\"]\n",
    "            filtered_trg = cache_dict[\"trg\"]\n",
    "\n",
    "        self.src = filtered_src\n",
    "        self.trg = filtered_trg\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.src[index], self.trg[index]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.src)\n",
    "        \n",
    "\n",
    "train_ds = LangPairDataset(\"train\")\n",
    "val_ds = LangPairDataset(\"val\")"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:12.349048Z",
     "iopub.execute_input": "2023-12-15T09:32:12.349450Z",
     "iopub.status.idle": "2023-12-15T09:32:12.556008Z",
     "shell.execute_reply.started": "2023-12-15T09:32:12.349417Z",
     "shell.execute_reply": "2023-12-15T09:32:12.555034Z"
    },
    "trusted": true
   },
   "execution_count": 15,
   "outputs": [
    {
     "name": "stdout",
     "text": "save cache to .cache/de2en_train_128.npy\nsave cache to .cache/de2en_val_128.npy\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"source: {}\\ntarget: {}\".format(*train_ds[-1]))"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:12.558005Z",
     "iopub.execute_input": "2023-12-15T09:32:12.558691Z",
     "iopub.status.idle": "2023-12-15T09:32:12.563794Z",
     "shell.execute_reply.started": "2023-12-15T09:32:12.558653Z",
     "shell.execute_reply": "2023-12-15T09:32:12.562602Z"
    },
    "trusted": true
   },
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "text": "source: ein älterer mann sitzt mit einem jungen mit einem wagen vor einer fassade .\ntarget: an elderly man sits outside a storefront accompani@@ ed by a young boy with a cart .\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Tokenizer\n",
    "\n",
    "这里有两种处理方式，分别对应着 encoder 和 decoder 的 word embedding 是否共享，这里实现共享的方案"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word2idx = {\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "}\n",
    "idx2word = {value: key for key, value in word2idx.items()}\n",
    "index = len(idx2word)\n",
    "threshold = 1  # 出现次数低于此的token舍弃\n",
    "\n",
    "with open(\"../input/wmt16-de-en/vocab\", \"r\", encoding=\"utf8\") as file:\n",
    "    for line in tqdm(file.readlines()):\n",
    "        token, counts = line.strip().split()\n",
    "        if int(counts) >= threshold:\n",
    "            word2idx[token] = index\n",
    "            idx2word[index] = token\n",
    "            index += 1\n",
    "            \n",
    "vocab_size = len(word2idx)\n",
    "print(\"vocab_size: {}\".format(vocab_size))"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:57.920416Z",
     "iopub.execute_input": "2023-12-15T09:32:57.920902Z",
     "iopub.status.idle": "2023-12-15T09:32:57.975982Z",
     "shell.execute_reply.started": "2023-12-15T09:32:57.920865Z",
     "shell.execute_reply": "2023-12-15T09:32:57.975040Z"
    },
    "trusted": true
   },
   "execution_count": 18,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "  0%|          | 0/9714 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "1374a016f78e4d459fc3de71183de8d0"
      }
     },
     "metadata": {}
    },
    {
     "name": "stdout",
     "text": "vocab_size: 9718\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=128, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False, add_bos=True, add_eos=True, return_mask=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, add_eos + add_bos + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.word2idx.get(word, self.unk_idx) for word in text[:max_length - add_bos - add_eos]]\n",
    "            if add_bos:\n",
    "                indices = [self.bos_idx] + indices\n",
    "            if add_eos:\n",
    "                indices = indices + [self.eos_idx]\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        input_ids = torch.tensor(indices_list)\n",
    "        masks = (input_ids == self.pad_idx).to(dtype=torch.int64)\n",
    "        return input_ids if not return_mask else (input_ids, masks)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "\n",
    "tokenizer.encode([[\"hello\"], [\"hello\", \"world\"]], add_bos=True, add_eos=False)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=False, add_bos=False, add_eos=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:57.978226Z",
     "iopub.execute_input": "2023-12-15T09:32:57.978614Z",
     "iopub.status.idle": "2023-12-15T09:32:58.041924Z",
     "shell.execute_reply.started": "2023-12-15T09:32:57.978580Z",
     "shell.execute_reply": "2023-12-15T09:32:58.040955Z"
    },
    "trusted": true
   },
   "execution_count": 19,
   "outputs": [
    {
     "name": "stdout",
     "text": "raw text\n['hello', 'world']\n['tokenize', 'text', 'datas', 'with', 'batch']\n['this', 'is', 'a', 'test']\nindices\ntensor([   2, 4517,    3,    0,    0,    0])\ntensor([   2, 7167,    2,   22,    2,    3])\ntensor([ 425,   18,    5, 4493,    3,    0])\ndecode text\n[UNK] world [EOS] [PAD] [PAD] [PAD]\n[UNK] text [UNK] with [UNK] [EOS]\nthis is a test [EOS] [PAD]\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Transformer Batch Sampler\n",
    "\n",
    "> Sentence pairs were batched together by approximate sequence length. Each training batch contained a set of sentence pairs containing approximately 25000 source tokens and 25000 target tokens"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class SampleInfo:\n",
    "    def __init__(self, i, lens):\n",
    "        \"\"\"\n",
    "        记录文本对的序号和长度信息\n",
    "        输入：\n",
    "            - i (int): 文本对的序号。\n",
    "            - lens (list): 文本对源语言和目标语言的长度\n",
    "        \"\"\"\n",
    "        self.i = i\n",
    "        # 加一是考虑填补在文本前后的特殊词元\n",
    "        self.max_len = max(lens[0], lens[1]) + 1\n",
    "        self.src_len = lens[0] + 1\n",
    "        self.trg_len = lens[1] + 1\n",
    "\n",
    "\n",
    "class TokenBatchCreator:\n",
    "    def __init__(self, batch_size):\n",
    "        \"\"\"\n",
    "        按照词元数目限制的批量生成器\n",
    "        输入：\n",
    "            - batch_size (int): 批量大小限制\n",
    "        \"\"\"\n",
    "\n",
    "        self._batch = []\n",
    "        self.max_len = -1\n",
    "        self._batch_size = batch_size\n",
    "\n",
    "    def append(self, info):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - info (SampleInfo): 文本对的信息\n",
    "        \"\"\"\n",
    "        # 更新当前批量的最大长度\n",
    "        cur_len = info.max_len\n",
    "        max_len = max(self.max_len, cur_len)\n",
    "        # 如果新的样本加入批量后超过大小限制，则将已有的批量返回，新的样本加入新的批量\n",
    "        if max_len * (len(self._batch) + 1) > self._batch_size:\n",
    "            self._batch, result = [], self._batch\n",
    "            self._batch.append(info)\n",
    "            self.max_len = cur_len\n",
    "            return result\n",
    "        else:\n",
    "            self.max_len = max_len\n",
    "            self._batch.append(info)\n",
    "\n",
    "    @property\n",
    "    def batch(self):\n",
    "        return self._batch"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:58.042978Z",
     "iopub.execute_input": "2023-12-15T09:32:58.043240Z",
     "iopub.status.idle": "2023-12-15T09:32:58.052878Z",
     "shell.execute_reply.started": "2023-12-15T09:32:58.043217Z",
     "shell.execute_reply": "2023-12-15T09:32:58.051941Z"
    },
    "trusted": true
   },
   "execution_count": 20,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.data import BatchSampler\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "class TransformerBatchSampler(BatchSampler):\n",
    "    def __init__(self,\n",
    "                 dataset,\n",
    "                 batch_size,\n",
    "                 shuffle_batch=False,\n",
    "                 clip_last_batch=False,\n",
    "                 seed=0):\n",
    "        \"\"\"\n",
    "        批量采样器\n",
    "        输入:\n",
    "            - dataset: 数据集\n",
    "            - batch_size: 批量大小\n",
    "            - shuffle_batch: 是否对打乱生成的批量\n",
    "            - clip_last_batch: 是否裁剪最后剩下的数据\n",
    "            - seed: 随机数种子\n",
    "        \"\"\"\n",
    "        self._dataset = dataset\n",
    "        self._batch_size = batch_size\n",
    "        self._shuffle_batch = shuffle_batch\n",
    "        self._clip_last_batch = clip_last_batch\n",
    "        self._seed = seed\n",
    "        self._random = np.random\n",
    "        self._random.seed(seed)\n",
    "\n",
    "        self._sample_infos = []\n",
    "        for i, data in enumerate(self._dataset):\n",
    "            lens = [len(data[0]), len(data[1])]\n",
    "            self._sample_infos.append(SampleInfo(i, lens))\n",
    "\n",
    "    def __iter__(self):\n",
    "        \"\"\"\n",
    "        迭代采样。在这里TransformerBatchSampler将生成每一个批量数据在原数据集的序号，并在迭代中不断抛出。\n",
    "        \"\"\"\n",
    "        # 排序，如果源语言长度相同则按照目标语言的长度排列\n",
    "        infos = sorted(self._sample_infos,\n",
    "                       key=lambda x: (x.src_len, x.trg_len))\n",
    "        # 组装批量\n",
    "        batch_infos = []\n",
    "        batch_creator = TokenBatchCreator(self._batch_size)\n",
    "        for info in infos:\n",
    "            batch = batch_creator.append(info)\n",
    "            # 存够一个batch的样本信息后，会把这个batch返回，否则返回为None\n",
    "            if batch is not None:\n",
    "                batch_infos.append(batch)\n",
    "\n",
    "        # 是否抛弃最后批量的文本对\n",
    "        if not self._clip_last_batch and len(batch_creator.batch) != 0:\n",
    "            batch_infos.append(batch_creator.batch)\n",
    "\n",
    "        # 打乱批量\n",
    "        if self._shuffle_batch:\n",
    "            self._random.shuffle(batch_infos)\n",
    "\n",
    "        self.batch_number = len(batch_infos)\n",
    "\n",
    "        # 抛出一个批量的文本对在数据集中的序号\n",
    "        for batch in batch_infos:\n",
    "            batch_indices = [info.i for info in batch]\n",
    "            yield batch_indices\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"\n",
    "        返回批量的数量\n",
    "        \"\"\"\n",
    "        if hasattr(self, \"batch_number\"):\n",
    "            return self.batch_number\n",
    "        # 计算批量的数量\n",
    "        batch_number = (len(self._dataset) +\n",
    "                        self._batch_size) // self._batch_size\n",
    "        return batch_number"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:58.054738Z",
     "iopub.execute_input": "2023-12-15T09:32:58.055064Z",
     "iopub.status.idle": "2023-12-15T09:32:58.068929Z",
     "shell.execute_reply.started": "2023-12-15T09:32:58.055039Z",
     "shell.execute_reply": "2023-12-15T09:32:58.067973Z"
    },
    "trusted": true
   },
   "execution_count": 21,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "sampler = TransformerBatchSampler(train_ds, batch_size=4096, shuffle_batch=True)\n",
    "for idx, batch in enumerate(sampler):\n",
    "    print(\"第{}批量的数据中含有文本对的数目为：{}\".format(idx, len(batch)))\n",
    "    if idx >= 2:\n",
    "        break"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:58.070589Z",
     "iopub.execute_input": "2023-12-15T09:32:58.070970Z",
     "iopub.status.idle": "2023-12-15T09:32:58.188742Z",
     "shell.execute_reply.started": "2023-12-15T09:32:58.070916Z",
     "shell.execute_reply": "2023-12-15T09:32:58.187772Z"
    },
    "trusted": true
   },
   "execution_count": 22,
   "outputs": [
    {
     "name": "stdout",
     "text": "第0批量的数据中含有文本对的数目为：83\n第1批量的数据中含有文本对的数目为：49\n第2批量的数据中含有文本对的数目为：35\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### DataLoader"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "def collate_fct(batch, tokenizer):\n",
    "    src_words = [pair[0].split() for pair in batch]\n",
    "    trg_words = [pair[1].split() for pair in batch]\n",
    "    \n",
    "    # [BOS] src [EOS] [PAD]\n",
    "    encoder_inputs, encoder_inputs_mask = tokenizer.encode(\n",
    "        src_words, padding_first=False, add_bos=True, add_eos=True, return_mask=True\n",
    "        )\n",
    "    \n",
    "    # [BOS] trg [PAD]\n",
    "    decoder_inputs = tokenizer.encode(\n",
    "        trg_words, padding_first=False, add_bos=True, add_eos=False, return_mask=False,\n",
    "        )\n",
    "    \n",
    "    # trg [EOS] [PAD]\n",
    "    decoder_labels, decoder_labels_mask = tokenizer.encode(\n",
    "        trg_words, padding_first=False, add_bos=False, add_eos=True, return_mask=True\n",
    "        )\n",
    "\n",
    "    return {\n",
    "        \"encoder_inputs\": encoder_inputs.to(device=device),\n",
    "        \"encoder_inputs_mask\": encoder_inputs_mask.to(device=device),\n",
    "        \"decoder_inputs\": decoder_inputs.to(device=device),\n",
    "        \"decoder_labels\": decoder_labels.to(device=device),\n",
    "        \"decoder_labels_mask\": decoder_labels_mask.to(device=device),\n",
    "    }\n",
    "    "
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:58.189918Z",
     "iopub.execute_input": "2023-12-15T09:32:58.190234Z",
     "iopub.status.idle": "2023-12-15T09:32:58.199294Z",
     "shell.execute_reply.started": "2023-12-15T09:32:58.190198Z",
     "shell.execute_reply": "2023-12-15T09:32:58.198109Z"
    },
    "trusted": true
   },
   "execution_count": 23,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "from functools import partial\n",
    "\n",
    "\n",
    "sampler = TransformerBatchSampler(train_ds, batch_size=256, shuffle_batch=True)\n",
    "sample_dl = DataLoader(train_ds, batch_sampler=sampler, collate_fn=partial(collate_fct, tokenizer=tokenizer))\n",
    "\n",
    "for batch in sample_dl:\n",
    "    for key, value in batch.items():\n",
    "        print(key)\n",
    "        print(value)\n",
    "    break"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:32:58.202135Z",
     "iopub.execute_input": "2023-12-15T09:32:58.202580Z",
     "iopub.status.idle": "2023-12-15T09:33:00.982005Z",
     "shell.execute_reply.started": "2023-12-15T09:32:58.202544Z",
     "shell.execute_reply": "2023-12-15T09:33:00.981101Z"
    },
    "trusted": true
   },
   "execution_count": 24,
   "outputs": [
    {
     "name": "stdout",
     "text": "encoder_inputs\ntensor([[   1,    7,   17,    6,    8,   89,  157,   73,    7,  541,  255,    9,\n           14,   42,  153,  119, 1481,  406, 2384, 1319,    4,    3],\n        [   1,  521,    6,    8,  808, 1299, 2305, 1638, 2535,  184,   31, 1735,\n          961,   55, 1732,    4,    3,    0,    0,    0,    0,    0]],\n       device='cuda:0')\nencoder_inputs_mask\ntensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]],\n       device='cuda:0')\ndecoder_inputs\ntensor([[   1,    5,   16,    6,    5,   50,   41,   18,   78,    5,  421,  254,\n         7050,  106,  471,    4],\n        [   1,  452,    6,    5, 5010, 1118, 1010,  106,    5,  517, 5103,    4,\n            0,    0,    0,    0]], device='cuda:0')\ndecoder_labels\ntensor([[   5,   16,    6,    5,   50,   41,   18,   78,    5,  421,  254, 7050,\n          106,  471,    4,    3],\n        [ 452,    6,    5, 5010, 1118, 1010,  106,    5,  517, 5103,    4,    3,\n            0,    0,    0,    0]], device='cuda:0')\ndecoder_labels_mask\ntensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]], device='cuda:0')\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 定义模型\n",
    "\n",
    "- Transformer模型由Embedding、Transformer-Block组成\n",
    "- Embedding包括：\n",
    "    - WordEmbedding\n",
    "    - PositionEmbedding\n",
    "- Transformer-Block包括：\n",
    "    - Self-Attention\n",
    "    - Cross-Attention\n",
    "    - MLP"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Embedding"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "class TransformerEmbedding(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        # hyper params\n",
    "        self.vocab_size = config[\"vocab_size\"]\n",
    "        self.hidden_size = config[\"d_model\"]\n",
    "        self.pad_idx = config[\"pad_idx\"]\n",
    "        dropout_rate = config[\"dropout\"]\n",
    "        self.max_length = config[\"max_length\"]\n",
    "\n",
    "        # layers\n",
    "        self.word_embedding = nn.Embedding(\n",
    "            self.vocab_size, self.hidden_size, padding_idx=self.pad_idx\n",
    "        )\n",
    "        self.pos_embedding = nn.Embedding(\n",
    "            self.max_length,\n",
    "            self.hidden_size,\n",
    "            _weight=self.get_positional_encoding(\n",
    "                self.max_length, self.hidden_size\n",
    "            ),\n",
    "        )\n",
    "        self.pos_embedding.weight.requires_grad_(False)\n",
    "        self.dropout = nn.Dropout(dropout_rate)\n",
    "\n",
    "    def get_word_embedding_weights(self):\n",
    "        return self.word_embedding.weight\n",
    "\n",
    "    # 计算位置信息\n",
    "    @classmethod\n",
    "    def get_positional_encoding(self, max_length, hidden_size):\n",
    "        # Compute the positional encodings once in log space.\n",
    "        pe = torch.zeros(max_length, hidden_size)\n",
    "        position = torch.arange(0, max_length).unsqueeze(1)\n",
    "        div_term = torch.exp(\n",
    "            torch.arange(0, hidden_size, 2)\n",
    "            * -(torch.log(torch.Tensor([10000.0])) / hidden_size)\n",
    "        )\n",
    "        pe[:, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)\n",
    "        return pe\n",
    "\n",
    "    def forward(self, input_ids):\n",
    "        # input_ids: [batch_size, seq_len]\n",
    "        seq_len = input_ids.shape[1]\n",
    "        assert (\n",
    "            seq_len <= self.max_length\n",
    "        ), f\"input sequence length should no more than {self.max_length} but got {seq_len}\"\n",
    "\n",
    "        position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device)\n",
    "        position_ids = position_ids.unsqueeze(0).expand_as(input_ids)\n",
    "\n",
    "        # embedding\n",
    "        word_embeds = self.word_embedding(input_ids)\n",
    "        pos_embeds = self.pos_embedding(position_ids)\n",
    "        embeds = word_embeds + pos_embeds\n",
    "        embeds = self.dropout(embeds)\n",
    "\n",
    "        return embeds\n",
    "\n",
    "\n",
    "def plot_position_embedding(position_embedding):\n",
    "    plt.pcolormesh(position_embedding)\n",
    "    plt.xlabel('Depth')\n",
    "    plt.ylabel('Position')\n",
    "    plt.colorbar()\n",
    "    plt.show()\n",
    "\n",
    "position_embedding = TransformerEmbedding.get_positional_encoding(64, 64)\n",
    "plot_position_embedding(position_embedding)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:00.983164Z",
     "iopub.execute_input": "2023-12-15T09:33:00.983499Z",
     "iopub.status.idle": "2023-12-15T09:33:01.604954Z",
     "shell.execute_reply.started": "2023-12-15T09:33:00.983473Z",
     "shell.execute_reply": "2023-12-15T09:33:01.603998Z"
    },
    "trusted": true
   },
   "execution_count": 25,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Transformer Block"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### scaled-dot-product-attention"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Optional, Tuple\n",
    "\n",
    "Tensor = torch.Tensor\n",
    "\n",
    "@dataclass\n",
    "class AttentionOutput:\n",
    "    hidden_states: Tensor\n",
    "    attn_scores: Tensor\n",
    "\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        # hyper params\n",
    "        self.hidden_size = config[\"d_model\"]\n",
    "        self.num_heads = config[\"num_heads\"]\n",
    "        assert (\n",
    "            self.hidden_size % self.num_heads == 0\n",
    "        ), \"Hidden size must be divisible by num_heads but got {} and {}\".format(\n",
    "            self.hidden_size, self.num_heads\n",
    "        )\n",
    "        self.head_dim = self.hidden_size // self.num_heads\n",
    "\n",
    "        # layers\n",
    "        self.Wq = nn.Linear(self.hidden_size, self.hidden_size, bias=False)\n",
    "        self.Wk = nn.Linear(self.hidden_size, self.hidden_size, bias=False)\n",
    "        self.Wv = nn.Linear(self.hidden_size, self.hidden_size, bias=False)\n",
    "        self.Wo = nn.Linear(self.hidden_size, self.hidden_size, bias=False)\n",
    "\n",
    "    def _split_heads(self, x: Tensor) -> Tensor:\n",
    "        bs, seq_len, _ = x.shape\n",
    "        x = x.view(bs, seq_len, self.num_heads, self.head_dim)\n",
    "        return x.permute(0, 2, 1, 3)\n",
    "\n",
    "    def _merge_heads(self, x: Tensor) -> Tensor:\n",
    "        bs, _, seq_len, _ = x.shape\n",
    "        return x.permute(0, 2, 1, 3).reshape(bs, seq_len, self.hidden_size)\n",
    "\n",
    "    def forward(self, querys, keys, values, attn_mask=None) -> AttentionOutput:\n",
    "        # split heads\n",
    "        querys = self._split_heads(self.Wq(querys))\n",
    "        keys = self._split_heads(self.Wk(keys))\n",
    "        values = self._split_heads(self.Wv(values))\n",
    "\n",
    "        # calculate attention scores\n",
    "        qk_logits = torch.matmul(querys, keys.mT)\n",
    "        if attn_mask is not None:\n",
    "            attn_mask = attn_mask[:, :, : querys.shape[-2], : keys.shape[-2]]\n",
    "            qk_logits += attn_mask * -1e9\n",
    "        attn_scores = F.softmax(qk_logits / (self.head_dim**0.5), dim=-1)\n",
    "\n",
    "        # apply attention scores\n",
    "        embeds = torch.matmul(attn_scores, values)\n",
    "        embeds = self.Wo(self._merge_heads(embeds))\n",
    "\n",
    "        return AttentionOutput(hidden_states=embeds, attn_scores=attn_scores)\n",
    "        \n",
    "mha = MultiHeadAttention({\"num_heads\": 2, \"d_model\": 2})\n",
    "query = torch.randn(2, 3, 2)\n",
    "query /= query.norm(dim=-1, keepdim=True)\n",
    "key_value = torch.cat([query[:, :2], torch.randn(2, 2, 2)], dim=1)\n",
    "\n",
    "outputs = mha(query, key_value, key_value)\n",
    "\n",
    "fig, axis = plt.subplots(*outputs.attn_scores.shape[:2])\n",
    "for i in range(query.shape[0]):\n",
    "    for j in range(outputs.attn_scores.shape[1]):\n",
    "        axis[i, j].matshow(outputs.attn_scores[i, j].detach().numpy())\n",
    "        for x in range(outputs.attn_scores.shape[2]):\n",
    "            for y in range(outputs.attn_scores.shape[3]):\n",
    "                axis[i, j].text(y, x, f\"{outputs.attn_scores[i, j, x, y]:.2f}\", ha=\"center\", va=\"center\", color=\"w\")\n",
    "fig.suptitle(\"multi head attention without mask\")\n",
    "plt.show()\n",
    "\n",
    "# mask\n",
    "mask = torch.Tensor([[0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0]]).reshape(1, 1, 3, 4)\n",
    "outputs_masked = mha(query, key_value, key_value, mask)\n",
    "\n",
    "fig, axis = plt.subplots(*outputs_masked.attn_scores.shape[:2])\n",
    "for i in range(query.shape[0]):\n",
    "    for j in range(outputs_masked.attn_scores.shape[1]):\n",
    "        axis[i, j].matshow(outputs_masked.attn_scores[i, j].detach().numpy())\n",
    "        for x in range(outputs_masked.attn_scores.shape[2]):\n",
    "            for y in range(outputs_masked.attn_scores.shape[3]):\n",
    "                axis[i, j].text(y, x, f\"{outputs_masked.attn_scores[i, j, x, y]:.2f}\", ha=\"center\", va=\"center\", color=\"w\")\n",
    "fig.suptitle(\"multi head attention with mask\")\n",
    "plt.show()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:01.606473Z",
     "iopub.execute_input": "2023-12-15T09:33:01.606741Z",
     "iopub.status.idle": "2023-12-15T09:33:03.979981Z",
     "shell.execute_reply.started": "2023-12-15T09:33:01.606717Z",
     "shell.execute_reply": "2023-12-15T09:33:03.978612Z"
    },
    "trusted": true
   },
   "execution_count": 26,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 640x480 with 4 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 640x480 with 4 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Transformer-Block"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "@dataclass\n",
    "class TransformerBlockOutput:\n",
    "    hidden_states: Tensor\n",
    "    self_attn_scores: Tensor\n",
    "    cross_attn_scores: Optional[Tensor] = None\n",
    "\n",
    "class TransformerBlock(nn.Module):\n",
    "    def __init__(self, config, add_cross_attention=False):\n",
    "        super().__init__()\n",
    "        # hyper params\n",
    "        self.hidden_size = config[\"d_model\"]\n",
    "        self.num_heads = config[\"num_heads\"]\n",
    "        dropout_rate = config[\"dropout\"]\n",
    "        ffn_dim = config[\"dim_feedforward\"]\n",
    "        eps = config[\"layer_norm_eps\"]\n",
    "\n",
    "        # self-attention\n",
    "        self.self_atten = MultiHeadAttention(config)\n",
    "        self.self_ln = nn.LayerNorm(self.hidden_size, eps=eps)\n",
    "        self.self_dropout = nn.Dropout(dropout_rate)\n",
    "\n",
    "        # cross-attention\n",
    "        if add_cross_attention:\n",
    "            self.cross_atten = MultiHeadAttention(config)\n",
    "            self.cross_ln = nn.LayerNorm(self.hidden_size, eps=eps)\n",
    "            self.cross_dropout = nn.Dropout(dropout_rate)\n",
    "        else:\n",
    "            self.cross_atten = None\n",
    "\n",
    "        # FFN\n",
    "        self.ffn = nn.Sequential(\n",
    "            nn.Linear(self.hidden_size, ffn_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(ffn_dim, self.hidden_size),\n",
    "        )\n",
    "        self.ffn_ln = nn.LayerNorm(self.hidden_size, eps=eps)\n",
    "        self.ffn_dropout = nn.Dropout(dropout_rate)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        hidden_states,\n",
    "        attn_mask=None,\n",
    "        encoder_outputs=None,\n",
    "        cross_attn_mask=None,\n",
    "    ):\n",
    "        # self-attention\n",
    "        self_atten_output = self.self_atten(\n",
    "            hidden_states, hidden_states, hidden_states, attn_mask\n",
    "        )\n",
    "        self_embeds = self.self_ln(\n",
    "            hidden_states + self.self_dropout(self_atten_output.hidden_states)\n",
    "        )\n",
    "\n",
    "        # cross-attention\n",
    "        if self.cross_atten is not None:\n",
    "            assert encoder_outputs is not None\n",
    "            cross_atten_output = self.cross_atten(\n",
    "                self_embeds, encoder_outputs, encoder_outputs, cross_attn_mask\n",
    "            )\n",
    "            cross_embeds = self.cross_ln(\n",
    "                self_embeds + self.cross_dropout(cross_atten_output.hidden_states)\n",
    "            )\n",
    "\n",
    "        # FFN\n",
    "        embeds = cross_embeds if self.cross_atten is not None else self_embeds\n",
    "        ffn_output = self.ffn(embeds)\n",
    "        embeds = self.ffn_ln(embeds + self.ffn_dropout(ffn_output))\n",
    "\n",
    "        return TransformerBlockOutput(\n",
    "            hidden_states=embeds,\n",
    "            self_attn_scores=self_atten_output.attn_scores,\n",
    "            cross_attn_scores=cross_atten_output.attn_scores\n",
    "            if self.cross_atten is not None\n",
    "            else None,\n",
    "        )"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:03.982058Z",
     "iopub.execute_input": "2023-12-15T09:33:03.983082Z",
     "iopub.status.idle": "2023-12-15T09:33:04.005498Z",
     "shell.execute_reply.started": "2023-12-15T09:33:03.983028Z",
     "shell.execute_reply": "2023-12-15T09:33:04.004525Z"
    },
    "trusted": true
   },
   "execution_count": 27,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Encoder"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from typing import List\n",
    "\n",
    "@dataclass\n",
    "class TransformerEncoderOutput:\n",
    "    last_hidden_states: Tensor\n",
    "    attn_scores: List[Tensor]\n",
    "\n",
    "class TransformerEncoder(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        # hyper params\n",
    "        self.num_layers = config[\"num_encoder_layers\"]\n",
    "\n",
    "        # layers\n",
    "        self.layers = nn.ModuleList(\n",
    "            [TransformerBlock(config) for _ in range(self.num_layers)]\n",
    "        )\n",
    "\n",
    "    def forward(\n",
    "        self, encoder_inputs_embeds, attn_mask=None\n",
    "    ) -> TransformerEncoderOutput:\n",
    "        attn_scores = []\n",
    "        embeds = encoder_inputs_embeds\n",
    "        for layer in self.layers:\n",
    "            block_outputs = layer(embeds, attn_mask=attn_mask)\n",
    "            embeds = block_outputs.hidden_states\n",
    "            attn_scores.append(block_outputs.self_attn_scores)\n",
    "\n",
    "        return TransformerEncoderOutput(\n",
    "            last_hidden_states=embeds, attn_scores=attn_scores\n",
    "        )\n",
    "\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:04.006779Z",
     "iopub.execute_input": "2023-12-15T09:33:04.007092Z",
     "iopub.status.idle": "2023-12-15T09:33:04.020168Z",
     "shell.execute_reply.started": "2023-12-15T09:33:04.007067Z",
     "shell.execute_reply": "2023-12-15T09:33:04.019428Z"
    },
    "trusted": true
   },
   "execution_count": 28,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Decoder"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "@dataclass\n",
    "class TransformerDecoderOutput:\n",
    "    last_hidden_states: Tensor\n",
    "    self_attn_scores: List[Tensor]\n",
    "    cross_attn_scores: List[Tensor]\n",
    "\n",
    "\n",
    "class TransformerDecoder(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        # hyper params\n",
    "        self.num_layers = config[\"num_decoder_layers\"]\n",
    "\n",
    "        # layers\n",
    "        self.layers = nn.ModuleList(\n",
    "            [\n",
    "                TransformerBlock(config, add_cross_attention=True)\n",
    "                for _ in range(self.num_layers)\n",
    "            ]\n",
    "        )\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        decoder_inputs_embeds,\n",
    "        encoder_outputs,\n",
    "        attn_mask=None,\n",
    "        cross_attn_mask=None,\n",
    "    ) -> TransformerDecoderOutput:\n",
    "        self_attn_scores = []\n",
    "        cross_attn_scores = []\n",
    "        embeds = decoder_inputs_embeds\n",
    "        for layer in self.layers:\n",
    "            block_outputs = layer(\n",
    "                embeds,\n",
    "                attn_mask=attn_mask,\n",
    "                encoder_outputs=encoder_outputs,\n",
    "                cross_attn_mask=cross_attn_mask,\n",
    "            )\n",
    "            embeds = block_outputs.hidden_states\n",
    "            self_attn_scores.append(block_outputs.self_attn_scores)\n",
    "            cross_attn_scores.append(block_outputs.cross_attn_scores)\n",
    "\n",
    "        return TransformerDecoderOutput(\n",
    "            last_hidden_states=embeds,\n",
    "            self_attn_scores=self_attn_scores,\n",
    "            cross_attn_scores=cross_attn_scores,\n",
    "        )\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:04.021616Z",
     "iopub.execute_input": "2023-12-15T09:33:04.021994Z",
     "iopub.status.idle": "2023-12-15T09:33:04.033847Z",
     "shell.execute_reply.started": "2023-12-15T09:33:04.021961Z",
     "shell.execute_reply": "2023-12-15T09:33:04.032953Z"
    },
    "trusted": true
   },
   "execution_count": 29,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### mask\n",
    "\n",
    "- mask实际上只有两种\n",
    "    1. `padding_mask`：mask掉`pad_idx`，不计算损失\n",
    "    2. `attention_mask`：mask掉`pad_idx`，不计算注意力分数\n",
    "- Decoder的`attention_mask`和Encoder有一定的区别：\n",
    "    - Encoder可以同时看见序列所有信息，故只mask掉`pad_idx`\n",
    "    - Decoder只能看到在自身之前的序列的信息，故要额外mask掉自身之后的序列"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "def generate_square_subsequent_mask(sz: int) -> Tensor:\n",
    "    \"\"\"\n",
    "    Generate a square mask for the sequence. The masked positions are filled with True.\n",
    "        Unmasked positions are filled with False.\n",
    "    \"\"\"\n",
    "    mask = (torch.triu(torch.ones(sz, sz)) == 0).transpose(-1, -2).bool()\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "plt.matshow(generate_square_subsequent_mask(16))\n",
    "plt.colorbar()\n",
    "plt.xlabel(\"keys\")\n",
    "plt.ylabel(\"querys\")\n",
    "plt.title(\"1 means mask while 0 means unmask\")\n",
    "plt.show()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:04.038293Z",
     "iopub.execute_input": "2023-12-15T09:33:04.038799Z",
     "iopub.status.idle": "2023-12-15T09:33:04.604806Z",
     "shell.execute_reply.started": "2023-12-15T09:33:04.038741Z",
     "shell.execute_reply": "2023-12-15T09:33:04.603883Z"
    },
    "trusted": true
   },
   "execution_count": 30,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 480x480 with 2 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbEAAAGZCAYAAAAHLw/qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGR0lEQVR4nO3deVxU5f4H8M8AMiCbuLApiqJpgoKBkJJbkmhKmhZuCaEtJqREmlIhZiriwsVyIb259FPTrqmZpaYkqWWhEqU310TFBZCrgmICzjy/P7zMdWKAgRmZOTOf9+t1XjnPnOV7YJovz3YemRBCgIiISIIsDB0AERFRfTGJERGRZDGJERGRZDGJERGRZDGJERGRZDGJERGRZDGJERGRZDGJERGRZDGJERGRZDGJkcGsXbsWMpkMR48ebbBr9u3bF76+vrXud+HCBchkMqxdu1ZVNmvWLMhkskcYHZm7ys9YUVGRoUORDEknsTt37iApKQkDBw5E06ZNq3zpEBm7srIyTJ8+HR4eHrC1tUVwcDD27t1r6LCIJEPSSayoqAizZ8/GyZMn4efnZ+hwyIS0adMGf/31F8aNG/dIr/Pyyy8jNTUVY8eOxZIlS2BpaYlnn30Whw4deqTXJTIVVoYOQBfu7u64du0a3NzccPToUXTv3t3QIZGJkMlksLGxeaTXyMrKwqZNm7Bw4UJMnToVABAZGQlfX1+88847+Omnnx7p9YlMgaRrYnK5HG5ubvU+/uWXX4a9vT0uXbqEIUOGwN7eHi1btsSyZcsAAMePH8fTTz8NOzs7tGnTBhs3bqxyjlu3biEuLg6enp6Qy+Vo3749UlJSoFQq1fZbtGgRevbsiWbNmsHW1hYBAQHYsmVLlfPJZDLExsZi+/bt8PX1hVwuh4+PD3bv3q223+3btxEXFwcvLy/I5XK4uLjgmWeeQXZ2do33XNnmfubMGbz00ktwcnJCixYtkJiYCCEE8vLyMHToUDg6OsLNzQ2LFy9WO768vBwzZ85EQEAAnJycYGdnh169emH//v1VrrVp0yYEBATAwcEBjo6O6NKlC5YsWVJjfDdv3kRQUBBatWqF06dPa9zn1q1bsLS0xEcffaQqKyoqgoWFBZo1a4aHF2Z44403NH5G/vjjD/Tr1w+NGzdGy5YtsWDBArX3NfWJVWf9+vUICAiAra0tmjZtilGjRiEvL6/W47Zs2QJLS0u89tprqjIbGxtMmDABhw8frvUclf17v//+O/r06YPGjRujffv2qs/VDz/8gODgYNja2qJjx47Yt29flXNcuXIF48ePh6urq+qztnr1arV9tP2dV/7MFi1ahJUrV8Lb2xtyuRzdu3fHkSNH1PbNz89HdHQ0WrVqBblcDnd3dwwdOhQXLlyo9Z779u1bpfzll1+Gl5dXvWLR9Xvgxo0bmDp1Krp06QJ7e3s4Ojpi0KBB+O2336rE+fHHH8PHxweNGzeGs7MzAgMDNX6vPOzixYto3749fH19UVBQUOO+hnTgwAGEh4fDw8MDMpkM27dvr/WYzMxMPPHEE6rvzvp0B0k6iemDQqHAoEGD4OnpiQULFsDLywuxsbFYu3YtBg4ciMDAQKSkpMDBwQGRkZHIzc1VHXv37l306dMH69evR2RkJD766COEhIQgISEB8fHxatdZsmQJunXrhtmzZ2PevHmwsrLCiy++iG+++aZKTIcOHcKkSZMwatQoLFiwAPfu3cOIESPwn//8R7XPxIkTsWLFCowYMQLLly/H1KlTYWtri5MnT2p13yNHjoRSqcT8+fMRHByMOXPmIC0tDc888wxatmyJlJQUtG/fHlOnTsWBAwdUx5WUlOCf//wn+vbti5SUFMyaNQvXr19HWFgYcnJyVPvt3bsXo0ePhrOzM1JSUjB//nz07dsXP/74Y7UxFRUV4emnn0ZBQQF++OEHdOzYUeN+TZo0ga+vr1pchw4dgkwmw40bN/DHH3+oyg8ePIhevXqpHX/z5k0MHDgQfn5+WLx4MTp16oTp06dj165dWv3sHjZ37lxERkaiQ4cOSE1NRVxcHDIyMtC7d2/cunWrxmN//fVXPPbYY3B0dFQrDwoKAgC1n2d1bt68iSFDhiA4OBgLFiyAXC7HqFGjsHnzZowaNQrPPvss5s+fj9LSUrzwwgu4ffu26tiCggI8+eST2LdvH2JjY7FkyRK0b98eEyZMQFpammo/bX/nlTZu3IiFCxfi9ddfx5w5c3DhwgUMHz4cFRUVqn1GjBiBbdu2ITo6GsuXL8fkyZNx+/ZtXLp0qdZ7rgttYgF0+x44f/48tm/fjiFDhiA1NRXTpk3D8ePH0adPH1y9elW136pVqzB58mR07twZaWlp+OCDD+Dv749ffvml2vj//PNP9O7dGw4ODsjMzISrq6tefz76VFpaCj8/P1Xyr01ubi4GDx6Mfv36IScnB3FxcXjllVewZ8+eul1YmIgjR44IAGLNmjVaHxMVFSUAiHnz5qnKbt68KWxtbYVMJhObNm1SlZ86dUoAEElJSaqyDz/8UNjZ2YkzZ86onXfGjBnC0tJSXLp0SVV29+5dtX3Ky8uFr6+vePrpp9XKAQhra2tx7tw5Vdlvv/0mAIiPP/5YVebk5CRiYmK0vtdKSUlJAoB47bXXVGX3798XrVq1EjKZTMyfP19VXvmziIqKUtu3rKxM7Zw3b94Urq6uYvz48aqyKVOmCEdHR3H//v1qY1mzZo0AII4cOSKuXbsmfHx8RLt27cSFCxdqvY+YmBjh6uqqeh0fHy969+4tXFxcxIoVK4QQQvznP/8RMplMLFmyRLVfnz59BADx2WefqcrKysqEm5ubGDFihKosNze3yuep8mdX6cKFC8LS0lLMnTtXLbbjx48LKyurKuV/5+PjU+X3L4QQ//73vwUAkZ6eXuPxlfeyceNGVVnl59TCwkL8/PPPqvI9e/ZUuZ8JEyYId3d3UVRUpHbeUaNGCScnJ9VnVtvfeeXPrFmzZuLGjRuq8q+++koAEF9//bXqWABi4cKFNd5fdffcp0+fKuVRUVGiTZs2dY6l8lhdvgfu3bsnFAqFWjy5ublCLpeL2bNnq8qGDh0qfHx8ary/ys/Y9evXxcmTJ4WHh4fo3r272j1IAQCxbdu2Gvd55513qvw8Ro4cKcLCwup0LbOviQHAK6+8ovp3kyZN0LFjR9jZ2SEiIkJV3rFjRzRp0gTnz59Xlf3rX/9Cr1694OzsjKKiItUWGhoKhUKhVlOwtbVV/fvmzZsoLi5Gr169NDb/hYaGwtvbW/W6a9eucHR0VLt2kyZN8Msvv6j9pVffe7a0tERgYCCEEJgwYUKVn8XD17W0tIS1tTUAQKlU4saNG7h//z4CAwPV7qVJkyYoLS3VaqTd5cuX0adPH1RUVODAgQNo06ZNrcf06tULBQUFqibHgwcPonfv3ujVqxcOHjwI4EHtTAhRpSZmb2+Pl156SfXa2toaQUFBavepja1bt0KpVCIiIkLt9+/m5oYOHTpobGJ92F9//QW5XF6lvLIv7q+//qo1Bnt7e4waNUr1uvJz+vjjjyM4OFhVXvnvynsUQuDLL79EeHg4hBBq8YeFhaG4uFj1+9T2d15p5MiRcHZ2Vr2u/PlXXtvW1hbW1tbIzMzEzZs3a71HXdQWy8Pq+z0gl8thYfHgq1ShUOA///kP7O3t0bFjxyr/T1y+fLlKc6YmJ06cQJ8+feDl5YV9+/ap3YOpOHz4MEJDQ9XKwsLCcPjw4TqdR9IDO/TBxsYGLVq0UCtzcnJCq1atqswJcnJyUvuf7uzZs/j999+rHF+psLBQ9e+dO3dizpw5yMnJQVlZmapc07yj1q1bVylzdnZWu/aCBQsQFRUFT09PBAQE4Nlnn0VkZCTatWtXyx1rvoaTkxNsbGzQvHnzKuUPN2MCwLp167B48WKcOnVKrVmmbdu2qn9PmjQJX3zxBQYNGoSWLVtiwIABiIiIwMCBA6vEMm7cOFhZWeHkyZNa93FWfhkdPHgQrVq1wq+//oo5c+agRYsWWLRokeo9R0fHKiNXNf1unZ2d8fvvv2t17Upnz56FEAIdOnTQ+H6jRo1qPN7W1lbts1Dp3r17qvdrU93n1NPTs0oZANVn6Pr167h16xZWrlyJlStXajz3w59fbX7nlf7+2ar8Aq68tlwuR0pKCt5++224urriySefxJAhQxAZGalTH7cmtcVSSZfvAaVSiSVLlmD58uXIzc2FQqFQvdesWTPVv6dPn459+/YhKCgI7du3x4ABAzBmzBiEhIRUiTs8PByurq7Ys2cP7O3t63TP9+7dQ3l5eZ2OqY4Qosr9y+VyjX981VV+fn6V5lFXV1eUlJTgr7/+0urzDzCJwdLSsk7l4qFBA0qlEs888wzeeecdjfs+9thjAB58mT733HPo3bs3li9fDnd3dzRq1Ahr1qzR2KmrzbUjIiLQq1cvbNu2Dd999x0WLlyIlJQUbN26FYMGDdJ8s7VcQ5vrrl+/Hi+//DKGDRuGadOmwcXFBZaWlkhOTsaff/6p2s/FxQU5OTnYs2cPdu3ahV27dmHNmjWIjIzEunXr1M4/fPhwfPbZZ1iyZAmSk5NrjR0APDw80LZtWxw4cABeXl4QQqBHjx5o0aIFpkyZgosXL+LgwYPo2bOn6q/kutynNpRKJWQyGXbt2qXxnLV9+bi7u+PKlStVyq9duwbgwT3Wpr6f38qBRy+99BKioqI07tu1a1cA2v/Otb02AMTFxSE8PBzbt2/Hnj17kJiYiOTkZHz//ffo1q1bNXf74I8+Tb+nhxNHXWOpaT9tjp83bx4SExMxfvx4fPjhh2jatCksLCwQFxenNsDr8ccfx+nTp7Fz507s3r0bX375JZYvX46ZM2figw8+UDv/iBEjsG7dOmzYsAGvv/66xhg0uXfvHtq2sUd+oeafR13Z29vjzp07amVJSUmYNWuWXs6vD2afxHTh7e2NO3fuVKkS/92XX34JGxsb7NmzR+0vmDVr1uh0fXd3d0yaNAmTJk1CYWEhnnjiCcydO1erJFZfW7ZsQbt27bB161a1v9CSkpKq7GttbY3w8HCEh4dDqVRi0qRJ+OSTT5CYmIj27dur9nvzzTfRvn17zJw5E05OTpgxY4ZWsfTq1QsHDhxA27Zt4e/vDwcHB/j5+cHJyQm7d+9GdnZ2lS8HffL29oYQAm3btlX9wVIX/v7+2L9/P0pKStQGd1R29Pv7++sr1CpatGgBBwcHKBSKWj+/dfmd14W3tzfefvttvP322zh79iz8/f2xePFirF+/vtpjnJ2dNTYFXrx4UadYdLFlyxb069cPn376qVr5rVu3qrRs2NnZYeTIkRg5ciTKy8sxfPhwzJ07FwkJCWpTOhYuXAgrKytMmjQJDg4OGDNmjFaxlJeXI79QgdxjbeDooFtvUcltJdoGXEReXp7a51MftTAAcHNzqzLasqCgAI6OjlrXwgCOTtRJREQEDh8+rHE0za1bt3D//n0AD/6ak8lkan8tXrhwQashqJooFAoUFxerlbm4uMDDw0Nj85Q+Vf5l+vBfor/88kuVduy/N0FaWFio/rLXFGNiYiKmTp2KhIQErFixQqtYevXqhQsXLmDz5s2q5kULCwv07NkTqampqKioqNIfpk/Dhw+HpaUlPvjggyp/2QshqvwM/u6FF16AQqFQa84rKyvDmjVrEBwcXKVJUJ8sLS0xYsQIfPnllzhx4kSV969fv662L1D771xbd+/eVTWZVvL29oaDg0Otn19vb2+cOnVKLb7ffvutxlGvj5qlpWWV3/+//vWvKrXsv38erK2t0blzZwghqoyWlMlkWLlyJV544QVERUVhx44ddYrJzl4/GwA4OjqqbfpKYj169EBGRoZa2d69e9GjR486nUfyNbGlS5fi1q1bqgEOX3/9NS5fvgzgwV/4lX0Bj8K0adOwY8cODBkyBC+//DICAgJQWlqK48ePY8uWLbhw4QKaN2+OwYMHIzU1FQMHDsSYMWNQWFiIZcuWoX379nXuhwEezBFr1aoVXnjhBfj5+cHe3h779u3DkSNHqszr0rchQ4Zg69ateP755zF48GDk5uYiPT0dnTt3Vmt2eOWVV3Djxg08/fTTaNWqFS5evIiPP/4Y/v7+ePzxxzWee+HChSguLkZMTAwcHBzUBl9oUpmgTp8+jXnz5qnKe/fujV27dqnmBT0q3t7emDNnDhISEnDhwgUMGzYMDg4OyM3NxbZt2/Daa6+pJjFrEhwcjBdffBEJCQkoLCxE+/btsW7dOly4cKHKX/WPwvz587F//34EBwfj1VdfRefOnXHjxg1kZ2dj3759uHHjBgDtf+faOnPmDPr374+IiAh07twZVlZW2LZtGwoKCtQGqWgyfvx4pKamIiwsDBMmTEBhYSHS09Ph4+ODkpKSev0cdDVkyBDMnj0b0dHR6NmzJ44fP44NGzZU6Z8eMGAA3NzcEBISAldXV5w8eRJLly7F4MGD4eDgUOW8FhYWWL9+PYYNG4aIiAh8++23ePrppxvqturszp07OHfunOp1bm4ucnJy0LRpU7Ru3RoJCQm4cuUKPvvsMwAPpgktXboU77zzDsaPH4/vv/8eX3zxhcZpRzWq01hGI9SmTRsBQOOWm5tb47FRUVHCzs6uSnmfPn00DoVt06aNGDx4sFrZ7du3RUJCgmjfvr2wtrYWzZs3Fz179hSLFi0S5eXlqv0+/fRT0aFDByGXy0WnTp3EmjVrqgzZFuLB0FRNQ+fbtGmjGupeVlYmpk2bJvz8/ISDg4Ows7MTfn5+Yvny5TXerxDqQ3jr87NQKpVi3rx5ok2bNkIul4tu3bqJnTt3VhnivGXLFjFgwADh4uIirK2tRevWrcXrr78url27ptrn4SH2lRQKhRg9erSwsrIS27dvr/V+XFxcBABRUFCgKjt06JAAIHr16lXr/Tx8/5qGaNc0xL7Sl19+KZ566ilhZ2cn7OzsRKdOnURMTIw4ffp0rfH/9ddfYurUqcLNzU3I5XLRvXt3sXv37lqPq+leNH1OhdD82SooKBAxMTHC09NTNGrUSLi5uYn+/fuLlStXqvbR9nde+TPTNHQeDw1LLyoqEjExMaJTp07Czs5OODk5ieDgYPHFF19odd/r168X7dq1E9bW1sLf31/s2bOn3rEIofv3wL1798Tbb78t3N3dha2trQgJCRGHDx+uMh3gk08+Eb179xbNmjUTcrlceHt7i2nTponi4mLVPpr+/7x7967o06ePsLe3V5s2oUlxcbEAIPJPtxZ3r3rptOWfbi0AqMVXk/3792v8Hq783oqKiqoyPWL//v3C399fWFtbi3bt2tVpilQlmRB17M0mIiKjVFJSAicnJ1w93UovfWIeHS+juLi4yoR8Y8I+MSIikizJ94kREZE6hRBQ6NjIpuvxDYVJjIjIxCghoIRuSUjX4xsKmxOJiEiyWBMjIjIxSggozKQmxiRGRGRi2JxIREQkAayJERGZGHManciaGIBly5bBy8sLNjY2CA4ORlZWlsFiSU5ORvfu3eHg4AAXFxcMGzZMtWaWsZg/fz5kMhni4uIMGseVK1fw0ksvoVmzZrC1tUWXLl1w9OhRg8akUCiQmJiItm3bwtbWFt7e3vjwww/r/IR8XdS2TLwQAjNnzoS7uztsbW0RGhqKs2fPGiymiooKTJ8+HV26dIGdnR08PDwQGRlZ77Xy9BHT302cOBEymUxtxWtjptTTJgVmn8Q2b96M+Ph4JCUlITs7G35+fggLC1NbS6kh/fDDD4iJicHPP/+MvXv3oqKiAgMGDEBpaalB4vm7I0eO4JNPPlE9zNdQbt68iZCQEDRq1Ai7du3CH3/8gcWLFxt88cCUlBSsWLECS5cuxcmTJ5GSkoIFCxbg448/brAYalsmfsGCBfjoo4+Qnp6OX375BXZ2dggLC6vyUN6Giunu3bvIzs5GYmIisrOzsXXrVpw+fRrPPffcI4untpgetm3bNvz8889aLY1jLBT/Hdih6yYJdX5QlYkJCgpSe56cQqEQHh4eIjk52YBR/U9hYaEAIH744QdDhyJu374tOnToIPbu3Sv69OkjpkyZYrBYpk+fLp566imDXb86gwcPFuPHj1crGz58uBg7dqxB4sHflolXKpXCzc1N7ZmCt27dEnK5XHz++ecGiUmTrKwsAUBcvHjRoDFdvnxZtGzZUpw4cUK0adNG/OMf/2iQeOqr8tmJ/z7pIi5ddtNp+/dJlzo9O9FQzLomVl5ejmPHjqmtp2RhYYHQ0NB6LzOhb5VLrjRt2tTAkQAxMTEYPHhwretPNYQdO3YgMDAQL774IlxcXNCtWzesWrXK0GGhZ8+eyMjIwJkzZwA8WCbk0KFDj3SNt7rIzc1Ffn6+2u/QyckJwcHBRvOZBx587mUyGZo0aWKwGJRKJcaNG4dp06bBx8fHYHHUh0LoZ5MCsx7YUVRUBIVCoXGJ7FOnThkoqv9RKpWIi4tDSEgIfH19DRrLpk2bkJ2djSNHjhg0jkrnz5/HihUrEB8fj3fffRdHjhzB5MmTYW1tXe1KxQ1hxowZKCkpQadOnWBpaQmFQoG5c+di7NixBovpYfn5+QCg8TNf+Z6h3bt3D9OnT8fo0aMN+uDZlJQUWFlZYfLkyQaLob700acllT4xs05ixi4mJgYnTpzAoUOHDBpHXl4epkyZgr1796qtPmtISqUSgYGBqnXEunXrhhMnTiA9Pd2gSeyLL77Ahg0bsHHjRvj4+CAnJwdxcXHw8PAwaFxSUVFRgYiICAghtF4c9VE4duwYlixZguzsbLXVrMn4mHVzYvPmzWFpaalxiWw3NzcDRfVAbGwsdu7cif3796NVq1YGjeXYsWMoLCzEE088ASsrK1hZWeGHH37ARx99BCsrK7UVqxuKu7s7OnfurFb2+OOP49KlSw0ey8OmTZuGGTNmYNSoUejSpQvGjRuHt956C8nJyQaNq1Ll59oYP/OVCezixYvYu3evQWthBw8eRGFhIVq3bq36zF+8eBFvv/02vLy8DBaXtpSQQaHjpoQ0krdZJzFra2sEBASoLZGtVCqRkZFR5yWy9UUIgdjYWGzbtg3ff/892rZta5A4Hta/f38cP34cOTk5qi0wMBBjx45FTk6Oavn6hhQSElJl6sGZM2fQpk2bBo/lYXfv3oWFhfr/VpaWllAqjaNxpm3btnBzc1P7zJeUlOCXX34x2Gce+F8CO3v2LPbt24dmzZoZLBYAGDduHH7//Xe1z7yHhwemTZuGPXv2GDQ2bSiFfjYpMPvmxPj4eERFRSEwMBBBQUFIS0tDaWkpoqOjDRJPTEwMNm7ciK+++goODg6qfgonJyfY2toaJCYHB4cqfXJ2dnZo1qyZwfrq3nrrLfTs2RPz5s1DREQEsrKysHLlSqxcudIg8VQKDw/H3Llz0bp1a/j4+ODXX39Famoqxo8f32Ax1LZMfFxcHObMmYMOHTqgbdu2SExMhIeHB4YNG2aQmNzd3fHCCy8gOzsbO3fuhEKhUH3umzZtCmtr6waPqXXr1lUSaaNGjeDm5oaOHTs+kniongw9PNIYfPzxx6J169bC2tpaBAUF1boE+KMEDct7A6jXst2PkqGH2AshxNdffy18fX2FXC4XnTp1EitXrjRoPEIIUVJSIqZMmSJat24tbGxsRLt27cR7770nysrKGiyG2paJVyqVIjExUbi6ugq5XC769+8vTp8+bbCYcnNzq/3c79+/3yAxaSKlIfa//NtN/PuSh07bL/92k8QQe5kQEnm2CBER1aikpAROTk746d/usHfQrbfozm0levpcQ3FxsUH7J2tj1n1iREQkbWbfJ0ZEZGqUQgal0G10oa7HNxQmMSIiE1M5TF7Xc0gBmxOJiEiyWBMjIjIxClhAoWMdpeEfYVA/TGJERCZG6KFPTLBPjIiIDIF9YmamrKwMs2bNQllZmaFDUTHGmADjjIsxaYcxac9Y46KqONkZ/5sgaEyT+owxJsA442JM2mFM2jPWuGpTGfeu39vCTsfJzqW3lRjUNdfofwZsTiQiMjFKyKDUsaFNCWnUb9icSEREkmXyNTGlUomrV6/CwcGh2sXtSkpK1P5rDIwxJsA442JM2mFM2mvouIQQuH37Njw8PKos5VMf5jSww+T7xC5fvgxPT09Dh0FEVKu8vDydFsGt7BPb9lsH2Dnots5f6W0Fnvc7yz4xQ3NwcAAAPIVnYYVGOp9v25njOp+DiOhhJXeUaPPEBdX3FWnP5JNYZROiFRrBSqZ7EnPUccQPEVF1quvyqKsHAzt0fACwRJoTTT6JERGZG6UeHjvF0YlERESPmCSS2LJly+Dl5QUbGxsEBwcjKyvL0CERERkthbDQyyYFRh/l5s2bER8fj6SkJGRnZ8PPzw9hYWEoLCw0dGhEREZJCQu9bFJg9FGmpqbi1VdfRXR0NDp37oz09HQ0btwYq1evNnRoRERkYEY9sKO8vBzHjh1DQkKCqszCwgKhoaE4fPiwxmPKysrUHtppbJMoiYgeNYWQQaHjUiq6Ht9QjLomVlRUBIVCAVdXV7VyV1dX5OfnazwmOTkZTk5Oqo0TnYnI3FQuiqnrJgXSiLIOEhISUFxcrNry8vIMHRIRUYNSCgu9bFJg1M2JzZs3h6WlJQoKCtTKCwoK4ObmpvEYuVwOuVzeEOEREZGBGXWqtba2RkBAADIyMlRlSqUSGRkZ6NGjhwEjIyIyXubUnGjUNTEAiI+PR1RUFAIDAxEUFIS0tDSUlpYiOjra0KERERklJXQfmKHUTyiPnNEnsZEjR+L69euYOXMm8vPz4e/vj927d1cZ7EFERObH6JMYAMTGxiI2NtbQYRARSYI+JitLZbKzJJIYERFpTx+PjeJjp4iIiB4x1sTqKMzDXy/n2XM1Ry/nISL6O64nRkREksXmRCIiIglgTYyIyMToY7IyJzsTEZFBKIUMSl0nO/Mp9kRERI8Wa2JERCZGqYfmRE52JiIig9DHUipcioWIiAxCARkUOs7z0vX4hiKNVEtERKQBa2JERCaGzYlERCRZCujeHKjQTyiPnDRSLRERkQasiRERmRg2JxIRkWTxAcBERER1tGzZMnh5ecHGxgbBwcHIysqqcf+0tDR07NgRtra28PT0xFtvvYV79+7V6ZpMYkREJkb8dz0xXTZRx4EhmzdvRnx8PJKSkpCdnQ0/Pz+EhYWhsLBQ4/4bN27EjBkzkJSUhJMnT+LTTz/F5s2b8e6779bpukxiREQmprI5UdetLlJTU/Hqq68iOjoanTt3Rnp6Oho3bozVq1dr3P+nn35CSEgIxowZAy8vLwwYMACjR4+utfb2d+wTMxB9rRANcJVoInp0SkpK1F7L5XLI5XK1svLychw7dgwJCQmqMgsLC4SGhuLw4cMaz9uzZ0+sX78eWVlZCAoKwvnz5/Htt99i3LhxdYqPSYyIyMTocykWT09PtfKkpCTMmjVLrayoqAgKhQKurq5q5a6urjh16pTG848ZMwZFRUV46qmnIITA/fv3MXHixDo3JzKJERGZGH0uipmXlwdHR0dV+d9rYfWVmZmJefPmYfny5QgODsa5c+cwZcoUfPjhh0hMTNT6PExiRERULUdHR7Ukpknz5s1haWmJgoICtfKCggK4ublpPCYxMRHjxo3DK6+8AgDo0qULSktL8dprr+G9996DhYV2SZgDO4iITExlc6Kum7asra0REBCAjIyM/8WgVCIjIwM9evTQeMzdu3erJCpLS0sAgBBC62uzJkZEZGKUsNB5Ucu6Hh8fH4+oqCgEBgYiKCgIaWlpKC0tRXR0NAAgMjISLVu2RHJyMgAgPDwcqamp6Natm6o5MTExEeHh4apkpg2jTmLJycnYunUrTp06BVtbW/Ts2RMpKSno2LGjoUMjIjJaCiGDQseBHXU9fuTIkbh+/TpmzpyJ/Px8+Pv7Y/fu3arBHpcuXVKreb3//vuQyWR4//33ceXKFbRo0QLh4eGYO3duna4rE3WptzWwgQMHYtSoUejevTvu37+Pd999FydOnMAff/wBOzs7rc5RUlICJycn9MVQWMkaPeKIDYND7ImkreS2Es6PnUdxcXGt/U81nue/33dvHBwOub1u33dldyqwotdWnWN61Iy6JrZ7926112vXroWLiwuOHTuG3r17GygqIiLjps8h9sbOqJPY3xUXFwMAmjZtWu0+ZWVlKCsrU73++0Q9IiJTJ/TwFHvBBwDrl1KpRFxcHEJCQuDr61vtfsnJyXByclJtf5+oR0REpkMySSwmJgYnTpzApk2batwvISEBxcXFqi0vL6+BIiQiMg4KyPSySYEkmhNjY2Oxc+dOHDhwAK1atapxX03P9SIiMidKoXufltJoh/ypM+okJoTAm2++iW3btiEzMxNt27Y1dEhERGREjDqJxcTEYOPGjfjqq6/g4OCA/Px8AICTkxNsbW0NHB0RkXFS6mFgh67HNxSjjnLFihUoLi5G37594e7urto2b95s6NCIiIyWrgtiVm5SYNQ1MSOeh01EREbAqJMYERHVnSEeO2UoTGJERCbGnPrEmMRMQJiHv17Ow2cwEpHUMIkREZkYJfTw7EQO7CAiIkMQehhdKJjEiIjIEMzpKfbS6LkjIiLSgDUxIiITw9GJREQkWWxOJCIikgDWxIiITIw+nn3IIfZERGQQbE4kIiKSANbEiIhMjDnVxJjEiIhMjDklMTYnEhGRZLEmRkRkYsypJsYkRkRkYgR0HyIv9BPKI8ckRkRkYsypJsY+MSIikizWxEhFXytEA1wlmsiQzKkmxiRGRGRizCmJsTmRiIgkizUxIiITY041MSYxIiITI4QMQsckpOvxDYXNiUREJFmSSmLz58+HTCZDXFycoUMhIjJaleuJ6bpJgWSaE48cOYJPPvkEXbt2NXQoRERGzZz6xCRRE7tz5w7Gjh2LVatWwdnZ2dDhEBGRkZBEEouJicHgwYMRGhpa675lZWUoKSlR24iIzEnlwA5dNykw+ubETZs2ITs7G0eOHNFq/+TkZHzwwQePOCoiIuPF5kQjkZeXhylTpmDDhg2wsbHR6piEhAQUFxertry8vEccJRERGYpR18SOHTuGwsJCPPHEE6oyhUKBAwcOYOnSpSgrK4OlpaXaMXK5HHK5vKFDJSIyGuY0T8yok1j//v1x/PhxtbLo6Gh06tQJ06dPr5LAiIjoQQLStTmQSUwPHBwc4Ovrq1ZmZ2eHZs2aVSknIqIHBACh46qWUlkU06j7xIiIiGpi1DUxTTIzMw0dAhGRUVNCBpmOT9zgEzuIiMggzGlgB5sTiYhIslgTo0cizMNfb+faczVHb+ciMgdKIYPMTCY7M4kREZkYIfQwOlEiwxPZnEhERJLFmhgRkYkxp4EdTGJERCbGnJIYmxOJiEiyWBMjIjIxHJ1IRESSxdGJREREEsCaGBGRiXlQE9N1YIeegnnEmMSIiEyMOY1OZBIjIjIxArqvByaRihj7xIiISLpYEyMiMjFsTiQiIukyo/ZENicSEZFeLFu2DF5eXrCxsUFwcDCysrJq3P/WrVuIiYmBu7s75HI5HnvsMXz77bd1uiZrYkREpkYPzYmo4/GbN29GfHw80tPTERwcjLS0NISFheH06dNwcXGpsn95eTmeeeYZuLi4YMuWLWjZsiUuXryIJk2a1Om6TGJERCbGEE/sSE1Nxauvvoro6GgAQHp6Or755husXr0aM2bMqLL/6tWrcePGDfz0009o1KgRAMDLy6vOcbI5kYiIqlVSUqK2lZWVVdmnvLwcx44dQ2hoqKrMwsICoaGhOHz4sMbz7tixAz169EBMTAxcXV3h6+uLefPmQaFQ1Ck+1sTI6IV5+OvlPHuu5ujlPETGTp+jEz09PdXKk5KSMGvWLLWyoqIiKBQKuLq6qpW7urri1KlTGs9//vx5fP/99xg7diy+/fZbnDt3DpMmTUJFRQWSkpK0jpNJjIjI1AhZnfu0NJ4DQF5eHhwdHVXFcrlct/P+l1KphIuLC1auXAlLS0sEBATgypUrWLhwIZMYERHph6Ojo1oS06R58+awtLREQUGBWnlBQQHc3Nw0HuPu7o5GjRrB0tJSVfb4448jPz8f5eXlsLa21io+9okREZmYyoEdum7asra2RkBAADIyMlRlSqUSGRkZ6NGjh8ZjQkJCcO7cOSiVSlXZmTNn4O7urnUCA5jEiIhMj9DTVgfx8fFYtWoV1q1bh5MnT+KNN95AaWmparRiZGQkEhISVPu/8cYbuHHjBqZMmYIzZ87gm2++wbx58xATE1On6xp9Erty5QpeeuklNGvWDLa2tujSpQuOHj1q6LCIiOghI0eOxKJFizBz5kz4+/sjJycHu3fvVg32uHTpEq5du6ba39PTE3v27MGRI0fQtWtXTJ48GVOmTNE4HL8mRt0ndvPmTYSEhKBfv37YtWsXWrRogbNnz8LZ2dnQoRERGS1DPTsxNjYWsbGxGt/LzMysUtajRw/8/PPPdb7Ow4w6iaWkpMDT0xNr1qxRlbVt29aAERERSYREnn2oK6NuTtyxYwcCAwPx4osvwsXFBd26dcOqVasMHRYRkVGrrInpukmBUSex8+fPY8WKFejQoQP27NmDN954A5MnT8a6deuqPaasrKzKDHMiIjJNRt2cqFQqERgYiHnz5gEAunXrhhMnTiA9PR1RUVEaj0lOTsYHH3zQkGESERkXLsViHNzd3dG5c2e1sscffxyXLl2q9piEhAQUFxertry8vEcdJhGRkZHpaTN+Rl0TCwkJwenTp9XKzpw5gzZt2lR7jFwu19tjUYiIyLgZdU3srbfews8//4x58+bh3Llz2LhxI1auXFnnyXBERGbFAJOdDcWok1j37t2xbds2fP755/D19cWHH36ItLQ0jB071tChEREZLzNKYkbdnAgAQ4YMwZAhQwwdBhERGaF61cTy8vJw+fJl1eusrCzExcVh5cqVeguMiIjqqXIpFl03CahXEhszZgz2798PAMjPz8czzzyDrKwsvPfee5g9e7ZeAyQiorpp6KfYG1K9mhNPnDiBoKAgAMAXX3wBX19f/Pjjj/juu+8wceJEzJw5U69BEumDvlaIBrhKNJGxqFcSq6ioUA1j37dvH5577jkAQKdOndSeUkxERAbAyc418/HxQXp6Og4ePIi9e/di4MCBAICrV6+iWbNmeg2QiIjqiH1iNUtJScEnn3yCvn37YvTo0fDz8wPw4IG9lc2MREREj1q9mhP79u2LoqIilJSUqK3t9dprr6Fx48Z6C46IiOpOJh5sup5DCupVE0tKSsLly5erLE7p5eUFFxcXvQRGRET1ZEaTneuVxL766it4e3ujf//+2LhxI8rKyvQdFxER1Rf7xGqWk5ODI0eOwMfHB1OmTIGbmxveeOMNHDlyRN/xERERVavez07s1q0bPvroI1y9ehWffvopLl++jJCQEHTt2hVLlixBcXGxPuMkIiJtsTlRe0IIVFRUoLy8HEIIODs7Y+nSpfD09MTmzZv1ESMREdUFk1jtjh07htjYWLi7u+Ott95Ct27dcPLkSfzwww84e/Ys5s6di8mTJ+szViIiIjX1SmJdunTBk08+idzcXHz66afIy8vD/Pnz0b59e9U+o0ePxvXr1/UWKBERacmMamL1micWERGB8ePHo2XLltXu07x5cyiVynoHRkRE9aSP0YWmOjqxoqICa9euRUlJyaOIh4iISGt1rok1atQI9+7dexSxEBGRHvCJHbWIiYlBSkoK7t+/r+94iIhIV+wTq9mRI0eQkZGB7777Dl26dIGdnZ3a+1u3btVLcERERDWpVxJr0qQJRowYoe9YiIiI6qReSWzNmjX6joOIiPREBj30ieklkkevXkkMAO7fv4/MzEz8+eefGDNmDBwcHHD16lU4OjrC3t5enzESGZ0wD3+9nWvP1Ry9nYvI3NQriV28eBEDBw7EpUuXUFZWhmeeeQYODg5ISUlBWVkZ0tPT9R0nERFpi/PEajZlyhQEBgbi5s2bsLW1VZU///zzyMjI0FtwRERUDxydWLODBw/ip59+grW1tVq5l5cXrly5opfAiIionvSRhCSSxOpVE1MqlVAoFFXKL1++DAcHB52DIiIi0ka9ktiAAQOQlpamei2TyXDnzh0kJSXh2Wef1VdsRERUD5VP7NB1k4J6JbHFixfjxx9/ROfOnXHv3j2MGTNG1ZSYkpKit+AUCgUSExPRtm1b2NrawtvbGx9++CGEkMhPl4jIENgnVrNWrVrht99+w6ZNm/D777/jzp07mDBhAsaOHas20ENXKSkpWLFiBdatWwcfHx8cPXoU0dHRcHJy4lplRERU/3liVlZWeOmll/QZSxU//fQThg4disGDBwN4MHDk888/R1ZW1iO9LhGRpJnRwI56JbHPPvusxvcjIyPrFczf9ezZEytXrsSZM2fw2GOP4bfffsOhQ4eQmppa7TFlZWUoKytTveaSMURkbszpKfb1SmJTpkxRe11RUYG7d+/C2toajRs31lsSmzFjBkpKStCpUydYWlpCoVBg7ty5GDt2bLXHJCcn44MPPtDL9YmIyLjVa2DHzZs31bY7d+7g9OnTeOqpp/D555/rLbgvvvgCGzZswMaNG5GdnY1169Zh0aJFWLduXbXHJCQkoLi4WLXl5eXpLR4iIkmofGKHrpsE1LtP7O86dOiA+fPn46WXXsKpU6f0cs5p06ZhxowZGDVqFACgS5cuuHjxIpKTkxEVFaXxGLlcDrlcrpfrExFJkhn1idWrJlYdKysrXL16VW/nu3v3Liws1EO0tLSEUqnU2zWIiEi66lUT27Fjh9prIQSuXbuGpUuXIiQkRC+BAUB4eDjmzp2L1q1bw8fHB7/++itSU1Mxfvx4vV2DiMjUcGBHLYYNG6b2WiaToUWLFnj66aexePFifcQFAPj444+RmJiISZMmobCwEB4eHnj99dcxc+ZMvV2DiMjkmFFzYr2SWEM15zk4OCAtLU3tEVdERFQLfTw2ypSTWHx8vNb71jSni4iISBf1SmK//vorsrOzcf/+fXTs2BEAcObMGVhaWuKJJ55Q7SeTSWOIJhGRSWFzYs3Cw8Ph4OCAdevWwdnZGcCDuWPR0dHo1asX3n77bb0GSWTKwjz89XKePVdz9HIeMgFmlMTq/RT75ORkVQIDAGdnZ8yZM0evAzuIiIhqUq+aWElJCa5fv16l/Pr167h9+7bOQRERUf2Z0xD7etXEnn/+eURHR2Pr1q24fPkyLl++jC+//BITJkzA8OHD9R0jERGRRvWqiaWnp2Pq1KkYM2YMKioqHpzIygoTJkzAwoUL9RogERFRdeqVxBo3bozly5dj4cKF+PPPPwEA3t7esLOz02twRERUD2Y0sEOnBwDb2dmha9eu+oqFiIj0gH1iREREEqC3pViIiMiISKQmpSsmMSIiU2NGfWJsTiQiIsliTYyIyMSY08AOJjEiIlNjRs2JTGJERCbGnGpi7BMjIiLJYhIjIjI1Qk9bHS1btgxeXl6wsbFBcHAwsrKytDpu06ZNkMlkGDZsWJ2vySRGRGRqDJDENm/ejPj4eCQlJSE7Oxt+fn4ICwtDYWFhjcdduHABU6dORa9evep2wf9iEiMiIp2lpqbi1VdfRXR0NDp37oz09HQ0btwYq1evrvYYhUKBsWPH4oMPPkC7du3qdV0O7CAyEfpaIRrgKtFSp8+BHSUlJWrlcrkccrlcray8vBzHjh1DQkKCqszCwgKhoaE4fPhwtdeYPXs2XFxcMGHCBBw8eLBecbImRkRkavTYnOjp6QknJyfVlpycXOVyRUVFUCgUcHV1VSt3dXVFfn6+xhAPHTqETz/9FKtWrdLpVlkTIyKiauXl5cHR0VH1+u+1sPq4ffs2xo0bh1WrVqF58+Y6nYtJjIjI1OhxsrOjo6NaEtOkefPmsLS0REFBgVp5QUEB3Nzcquz/559/4sKFCwgPD1eVKZVKAA8WWD59+jS8vb21CpPNiUREJqayT0zXTVvW1tYICAhARkaGqkypVCIjIwM9evSosn+nTp1w/Phx5OTkqLbnnnsO/fr1Q05ODjw9PbW+NmtiRESks/j4eERFRSEwMBBBQUFIS0tDaWkpoqOjAQCRkZFo2bIlkpOTYWNjA19fX7XjmzRpAgBVymtj0JrYgQMHEB4eDg8PD8hkMmzfvl3tfSEEZs6cCXd3d9ja2iI0NBRnz541TLBERFJhgHliI0eOxKJFizBz5kz4+/sjJycHu3fvVg32uHTpEq5du6b7vf2NQWtipaWl8PPzw/jx4zF8+PAq7y9YsAAfffQR1q1bh7Zt2yIxMRFhYWH4448/YGNjY4CIiYiMn6GenRgbG4vY2FiN72VmZtZ47Nq1a+t+QRg4iQ0aNAiDBg3S+J4QAmlpaXj//fcxdOhQAMBnn30GV1dXbN++HaNGjWrIUImIyAgZ7cCO3Nxc5OfnIzQ0VFXm5OSE4ODgGifPlZWVoaSkRG0jIjIrBnp2oiEYbRKrnCBXl8lzAJCcnKw2Ma8uo1yIiEwCk5h0JSQkoLi4WLXl5eUZOiQiogYl09MmBUabxConyGk7ea6SXC5XTc7TZpIeERFJl9EmsbZt28LNzU1t8lxJSQl++eUXjZPniIjov8yoOdGgoxPv3LmDc+fOqV7n5uYiJycHTZs2RevWrREXF4c5c+agQ4cOqiH2Hh4e9Vo4jYjIXBhqiL0hGDSJHT16FP369VO9jo+PBwBERUVh7dq1eOedd1BaWorXXnsNt27dwlNPPYXdu3dzjhgREQEwcBLr27cvhKg+3ctkMsyePRuzZ89uwKiIiCROjw8ANnZ8diIRkSmSSBLSldEO7CAiIqoNa2JEVEWYh79ezrPnao5ezkN1w4EdREQkXWbUJ8bmRCIikizWxIiITAybE4mISLrYnEhERGT8WBMjIjIxbE4kIiLpMqPmRCYxIiJTY0ZJjH1iREQkWayJERGZGPaJERGRdLE5kYiIyPixJkZEZGJkQkBWw1qN2p5DCpjEiIhMDZsTiYiIjB9rYkREJoajE4mISLrMqDmRSYyIHhl9rRANcJVo0oxJjIjIxLA5kYiIpMuMmhM5OpGIiCSLNTEiIhPD5kQiIpIuNic2jAMHDiA8PBweHh6QyWTYvn276r2KigpMnz4dXbp0gZ2dHTw8PBAZGYmrV68aLmAiIomorI3Vd5MKgyax0tJS+Pn5YdmyZVXeu3v3LrKzs5GYmIjs7Gxs3boVp0+fxnPPPWeASImIyBgZtDlx0KBBGDRokMb3nJycsHfvXrWypUuXIigoCJcuXULr1q0bIkQiIukR4sGm6zkkQFJ9YsXFxZDJZGjSpEm1+5SVlaGsrEz1uqSkpAEiIyIyHuY0sEMyQ+zv3buH6dOnY/To0XB0dKx2v+TkZDg5Oak2T0/PBoySiIgakiSSWEVFBSIiIiCEwIoVK2rcNyEhAcXFxaotLy+vgaIkIjISQk+bBBh9c2JlArt48SK+//77GmthACCXyyGXyxsoOiIi4yNTPth0PYcUGHUSq0xgZ8+exf79+9GsWTNDh0REREbEoEnszp07OHfunOp1bm4ucnJy0LRpU7i7u+OFF15AdnY2du7cCYVCgfz8fABA06ZNYW1tbaiwiYiMmxlNdjZoEjt69Cj69euneh0fHw8AiIqKwqxZs7Bjxw4AgL+/v9px+/fvR9++fRsqTCIiSTGn0YkGTWJ9+/aFqGEuQk3vERERGXWfGBER1QMnOxMRkVSxOZGIyMiEefjr7Vx7rubo7VxkWExiRESmhqMTiYhIqticSERE0mVGAzsk8exEIiIiTVgTIyIyMWxOJCIi6TKjgR1sTiQiIsliTYyIyMSwOZGIiKRLKR5sup5DAticSEREksWaGBGRqTGjgR1MYkREJkYGPfSJ6SWSR4/NiUREJFmsiRERmRo+doqIiKSqcoi9rltdLVu2DF5eXrCxsUFwcDCysrKq3XfVqlXo1asXnJ2d4ezsjNDQ0Br3rw6TGBGRqRF62upg8+bNiI+PR1JSErKzs+Hn54ewsDAUFhZq3D8zMxOjR4/G/v37cfjwYXh6emLAgAG4cuVKna7LJEZERDpLTU3Fq6++iujoaHTu3Bnp6elo3LgxVq9erXH/DRs2YNKkSfD390enTp3wz3/+E0qlEhkZGXW6LpMYEZGJkQmhlw0ASkpK1LaysrIq1ysvL8exY8cQGhqqKrOwsEBoaCgOHz6sVcx3795FRUUFmjZtWqd75cAOIjI7YR7+ejnPnqs5ejmP3in/u+l6DgCenp5qxUlJSZg1a5ZaWVFRERQKBVxdXdXKXV1dcerUKa0uN336dHh4eKglQm0wiRERUbXy8vLg6Oioei2Xy/V+jfnz52PTpk3IzMyEjY1NnY5lEiMiMjEPNwfqcg4AcHR0VEtimjRv3hyWlpYoKChQKy8oKICbm1uNxy5atAjz58/Hvn370LVr1zrHyT4xIiJT08CjE62trREQEKA2KKNykEaPHj2qPW7BggX48MMPsXv3bgQGBtbhBv+HNTEiItJZfHw8oqKiEBgYiKCgIKSlpaG0tBTR0dEAgMjISLRs2RLJyckAgJSUFMycORMbN26El5cX8vPzAQD29vawt7fX+roGrYkdOHAA4eHh8PDwgEwmw/bt26vdd+LEiZDJZEhLS2uw+IiIJKnyiR26bnUwcuRILFq0CDNnzoS/vz9ycnKwe/du1WCPS5cu4dq1a6r9V6xYgfLycrzwwgtwd3dXbYsWLarTdQ1aEystLYWfnx/Gjx+P4cOHV7vftm3b8PPPP8PDw6MBoyMikiZDLYoZGxuL2NhYje9lZmaqvb5w4ULdL6CBQZPYoEGDMGjQoBr3uXLlCt58803s2bMHgwcPbqDIiIhICoy6T0ypVGLcuHGYNm0afHx8tDqmrKxMbTJeSUnJowqPiMg48QHAxiElJQVWVlaYPHmy1sckJyfDyclJtf19oh4RkamTKfWzSYHRJrFjx45hyZIlWLt2LWQy7ZdnS0hIQHFxsWrLy8t7hFESEZEhGW0SO3jwIAoLC9G6dWtYWVnBysoKFy9exNtvvw0vL69qj5PL5arJedpM0iMiMjkGGJ1oKEbbJzZu3Lgqz9AKCwvDuHHjVPMOiIhIg3ospaLxHBJg0CR2584dnDt3TvU6NzcXOTk5aNq0KVq3bo1mzZqp7d+oUSO4ubmhY8eODR0qEZFk6POxU8bOoEns6NGj6Nevn+p1fHw8ACAqKgpr1641UFRERCQVBk1iffv2hahDttfX5DgiIpNmRkPsjbZPjIiI6klA9/XEpJHDjHd0IhERUW1YEyMiqid9rRB9X1QAOK+XcwEc2EFERFImoIc+Mb1E8sixOZGIiCSLNTEiIlPD0YlERCRZSgDaP3K2+nNIAJsTiYhIslgTIyIyMRydSERE0mVGfWJsTiQiIsliTYyIyNSYUU2MSYyIyNQwiRERkWRxiD0REZHxY02MiMjEcIg9ERFJlxn1ibE5kYiIJIs1MSIiU6MUgEzHmpRSGjUxJjEiIlNjRs2JJp/ExH9/EfdRIZlF3ojIvNxHBYD/fV+R9kw+id2+fRsAcAjfGjgSIqKa3b59G05OTno4kx5qYhL5q9/kk5iHhwfy8vLg4OAAmUzz7L+SkhJ4enoiLy8Pjo6ODRyhZsYYE2CccTEm7TAm7TV0XEII3L59Gx4eHvo6IZsTTYWFhQVatWql1b6Ojo5G9T8SYJwxAcYZF2PSDmPSXkPGpZ8amPkx+SRGRGR2lAI6NwdydCIRERmEUD7YdD2HBHCyMwC5XI6kpCTI5XJDh6JijDEBxhkXY9IOY9KescZFVckEx3QSEZmEkpISODk5IdTzDVhZ6JaA7yvLsC9vBYqLi42yv7ISmxOJiEwN+8SIiEiyzGiIPfvEiIhIslgTIyIyNQJ6qInpJZJHjjUxMlt9+/ZFXFycocMg0r/K5kRdNwlgEiMiIslicyIRkalRKgHoOFlZycnORJLyzTffwMnJCRs2bEBeXh4iIiLQpEkTNG3aFEOHDsWFCxcAAAcOHECjRo2Qn5+vdnxcXBx69eoFALh48SLCw8Ph7OwMOzs7+Pj44NtvuZICNRA2JxKZl40bN2L06NHYsGEDIiIiEBYWBgcHBxw8eBA//vgj7O3tMXDgQJSXl6N3795o164d/u///k91fEVFBTZs2IDx48cDAGJiYlBWVoYDBw7g+PHjSElJgb29vaFuj8hksTmRzN6yZcvw3nvv4euvv0afPn2wfv16KJVK/POf/1Qt37NmzRo0adIEmZmZGDBgACZMmIA1a9Zg2rRpAICvv/4a9+7dQ0REBADg0qVLGDFiBLp06QIAaNeunWFujsyTGc0TYxIjs7ZlyxYUFhbixx9/RPfu3QEAv/32G86dOwcHBwe1fe/du4c///wTAPDyyy/j/fffx88//4wnn3wSa9euRUREBOzs7AAAkydPxhtvvIHvvvsOoaGhGDFiBLp27dqwN0fmy4ye2MHmRDJr3bp1Q4sWLbB69WrV0vB37txBQEAAcnJy1LYzZ85gzJgxAAAXFxeEh4djzZo1KCgowK5du1RNiQDwyiuv4Pz58xg3bhyOHz+OwMBAfPzxxwa5RyJTxpoYmTVvb28sXrwYffv2haWlJZYuXYonnngCmzdvhouLS40PPn3llVcwevRotGrVCt7e3ggJCVF739PTExMnTsTEiRORkJCAVatW4c0333zUt0QEIZQQOi6louvxDYU1MTJ7jz32GPbv348vv/wScXFxGDt2LJo3b46hQ4fi4MGDyM3NRWZmJiZPnozLly+rjgsLC4OjoyPmzJmD6OhotXPGxcVhz549yM3NRXZ2Nvbv34/HH3+8oW+NzJUQD5oDddnYJ0YkHR07dsT333+vqpEdOHAA06dPx/Dhw3H79m20bNkS/fv3V6uZWVhY4OWXX8a8efMQGRmpdj6FQoGYmBhcvnwZjo6OGDhwIP7xj3809G0RmTyuJ0akgwkTJuD69evYsWOHoUMhUq0n1t9pHKxk1jqd674oR0bx/3E9MSJTVFxcjOPHj2Pjxo1MYGR8lEpApmOflkT6xJjEiOph6NChyMrKwsSJE/HMM88YOhwidUIPQ+wl0kjHJEZUD5mZmYYOgYjAJEZEZHKEUgmhY3OiVIbYM4kREZkaM2pO5DwxIiKSLNbEiIhMjVIAMvOoiTGJERGZGiGg86KYEklibE4kIiLJYk2MiMjECKWA0LE5USoPc2JNjIjI1AilfrY6WrZsGby8vGBjY4Pg4GBkZWXVuP+//vUvdOrUCTY2NujSpQu+/fbbOl+TSYyIiHS2efNmxMfHIykpCdnZ2fDz80NYWBgKCws17v/TTz9h9OjRmDBhAn799VcMGzYMw4YNw4kTJ+p0XT4AmIjIRFQ+ALiv7HlYyRrpdK77ogKZYpvWDwAODg5G9+7dsXTpUgCAUqmEp6cn3nzzTcyYMaPK/iNHjkRpaSl27typKnvyySfh7++P9PR0reNkTYyIyNQ0cHNieXk5jh07htDQUFWZhYUFQkNDcfjwYY3HHD58WG1/4MEafdXtXx0O7CAiMjH3UaHzAzvuowLAg9rdw+RyOeRyuVpZUVERFAoFXF1d1cpdXV1x6tQpjefPz8/XuH9+fn6d4mQSIyIyEdbW1nBzc8Oh/LoPkNDE3t4enp6eamVJSUmYNWuWXs6vD0xiREQmwsbGBrm5uSgvL9fL+YQQkMlkamV/r4UBQPPmzWFpaYmCggK18oKCAri5uWk8t5ubW532rw6TGBGRCbGxsYGNjU2DXtPa2hoBAQHIyMjAsGHDADwY2JGRkYHY2FiNx/To0QMZGRmIi4tTle3duxc9evSo07WZxIiISGfx8fGIiopCYGAggoKCkJaWhtLSUkRHRwMAIiMj0bJlSyQnJwMApkyZgj59+mDx4sUYPHgwNm3ahKNHj2LlypV1ui6TGBER6WzkyJG4fv06Zs6cifz8fPj7+2P37t2qwRuXLl2ChcX/BsT37NkTGzduxPvvv493330XHTp0wPbt2+Hr61un63KeGBERSRbniRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWQxiRERkWT9P9BzPSgKCeGfAAAAAElFTkSuQmCC"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "inputs_words = [\"The quick brown fox jumps over the lazy dog .\", \"What does the fox say ?\"]\n",
    "\n",
    "inputs_ids, input_mask = tokenizer.encode([w.split() for w in inputs_words], return_mask=True)\n",
    "for i in range(len(inputs_words)):\n",
    "    decode_text = tokenizer.decode(inputs_ids[i: i+1].tolist(), remove_bos=False, remove_eos=False, remove_pad=False, split=True)[0]\n",
    "    print(decode_text)\n",
    "    self_attn_mask  = input_mask[i].reshape(1, -1).repeat_interleave(inputs_ids.shape[-1], dim=0)\n",
    "    look_ahead_mask = generate_square_subsequent_mask(inputs_ids.shape[-1])\n",
    "\n",
    "    fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n",
    "    axs[0].matshow(self_attn_mask)\n",
    "    axs[0].set_title(\"self_attn_mask\")\n",
    "    axs[0].set_yticks(range(len(decode_text)), decode_text, fontsize=6)\n",
    "    axs[0].set_ylabel(\"querys\")\n",
    "    axs[0].set_xticks(range(len(decode_text)), decode_text, fontsize=6)\n",
    "    axs[0].set_xlabel(\"keys\")\n",
    "    axs[1].matshow(look_ahead_mask)\n",
    "    axs[1].set_title(\"look_ahead_mask\")\n",
    "    axs[1].set_yticks(range(len(decode_text)), decode_text, fontsize=6)\n",
    "    axs[1].set_ylabel(\"querys\")\n",
    "    axs[1].set_xticks(range(len(decode_text)), decode_text, fontsize=6)\n",
    "    axs[1].set_xlabel(\"keys\")\n",
    "    plt.show()\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:04.606230Z",
     "iopub.execute_input": "2023-12-15T09:33:04.607035Z",
     "iopub.status.idle": "2023-12-15T09:33:06.464810Z",
     "shell.execute_reply.started": "2023-12-15T09:33:04.606997Z",
     "shell.execute_reply": "2023-12-15T09:33:06.463735Z"
    },
    "trusted": true
   },
   "execution_count": 31,
   "outputs": [
    {
     "name": "stdout",
     "text": "['[BOS]', '[UNK]', '[UNK]', 'brown', '[UNK]', 'jumps', 'over', 'the', '[UNK]', 'dog', '.', '[EOS]']\n",
     "output_type": "stream"
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "name": "stdout",
     "text": "['[BOS]', '[UNK]', 'does', 'the', '[UNK]', 'say', '?', '[EOS]', '[PAD]', '[PAD]', '[PAD]', '[PAD]']\n",
     "output_type": "stream"
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Transformer Model"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "@dataclass\n",
    "class TransformerOutput:\n",
    "    logits: Tensor\n",
    "    encoder_last_hidden_states: Tensor\n",
    "    encoder_attn_scores: List[Tensor]\n",
    "    decoder_last_hidden_states: Tensor\n",
    "    decoder_self_attn_scores: List[Tensor]\n",
    "    decoder_cross_attn_scores: List[Tensor]\n",
    "    preds: Optional[Tensor] = None\n",
    "\n",
    "class TransformerModel(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        # hyper params\n",
    "        self.hidden_size = config[\"d_model\"]\n",
    "        self.num_encoder_layers = config[\"num_encoder_layers\"]\n",
    "        self.num_decoder_layers = config[\"num_decoder_layers\"]\n",
    "        self.pad_idx = config[\"pad_idx\"]\n",
    "        self.bos_idx = config[\"bos_idx\"]\n",
    "        self.eos_idx = config[\"eos_idx\"]\n",
    "        self.vocab_size = config[\"vocab_size\"]\n",
    "        self.dropout_rate = config[\"dropout\"]\n",
    "        self.max_length = config[\"max_length\"]\n",
    "        self.share = config[\"share_embedding\"]\n",
    "\n",
    "        # layers\n",
    "        self.src_embedding = TransformerEmbedding(config)\n",
    "        if self.share:\n",
    "            self.trg_embedding = self.src_embedding\n",
    "            self.linear = lambda x: torch.matmul(\n",
    "                x, self.trg_embedding.get_word_embedding_weights().T\n",
    "            )\n",
    "        else:\n",
    "            self.trg_embedding = TransformerEmbedding(config)\n",
    "            self.linear = nn.Linear(self.hidden_size, self.vocab_size)\n",
    "\n",
    "        self.encoder = TransformerEncoder(config)\n",
    "        self.decoder = TransformerDecoder(config)\n",
    "\n",
    "        # init weights\n",
    "        self._init_weights()\n",
    "\n",
    "    def _init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化权重\"\"\"\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "\n",
    "    def generate_square_subsequent_mask(self, sz: int) -> Tensor:\n",
    "        \"\"\"\n",
    "        Generate a square mask for the sequence. The masked positions are filled with True.\n",
    "            Unmasked positions are filled with False.\n",
    "        \"\"\"\n",
    "        mask = (torch.triu(torch.ones(sz, sz)) == 0).transpose(-1, -2).bool()\n",
    "\n",
    "        return mask\n",
    "\n",
    "    def forward(\n",
    "        self, encoder_inputs, decoder_inputs, encoder_inputs_mask=None\n",
    "    ) -> TransformerOutput:\n",
    "        # encoder_inputs: [batch_size, src_len]\n",
    "        # decoder_inputs: [batch_size, trg_len]\n",
    "        # encoder_inputs_mask: [batch_size, src_len]\n",
    "        if encoder_inputs_mask is None:\n",
    "            encoder_inputs_mask = encoder_inputs.eq(self.pad_idx)\n",
    "        encoder_inputs_mask = encoder_inputs_mask.unsqueeze(1).unsqueeze(\n",
    "            2\n",
    "        )  # [batch_size, 1, 1, src_len]\n",
    "        look_ahead_mask = self.generate_square_subsequent_mask(decoder_inputs.shape[1])\n",
    "        look_ahead_mask = (\n",
    "            look_ahead_mask.unsqueeze(0).unsqueeze(0).to(decoder_inputs.device)\n",
    "        )  # [1, 1, trg_len, trg_len]\n",
    "\n",
    "        # encoding\n",
    "        encoder_inputs_embeds = self.src_embedding(encoder_inputs)\n",
    "        encoder_outputs = self.encoder(encoder_inputs_embeds, encoder_inputs_mask)\n",
    "\n",
    "        # decoding\n",
    "        decoder_inputs_embeds = self.trg_embedding(decoder_inputs)\n",
    "        decoder_outputs = self.decoder(\n",
    "            decoder_inputs_embeds=decoder_inputs_embeds,\n",
    "            encoder_outputs=encoder_outputs.last_hidden_states,\n",
    "            attn_mask=look_ahead_mask,\n",
    "            cross_attn_mask=encoder_inputs_mask,\n",
    "        )\n",
    "\n",
    "        logits = self.linear(decoder_outputs.last_hidden_states)\n",
    "\n",
    "        return TransformerOutput(\n",
    "            logits=logits,\n",
    "            encoder_last_hidden_states=encoder_outputs.last_hidden_states,\n",
    "            encoder_attn_scores=encoder_outputs.attn_scores,\n",
    "            decoder_last_hidden_states=decoder_outputs.last_hidden_states,\n",
    "            decoder_self_attn_scores=decoder_outputs.self_attn_scores,\n",
    "            decoder_cross_attn_scores=decoder_outputs.cross_attn_scores,\n",
    "        )\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def infer(self, encoder_inputs, encoder_inputs_mask=None) -> Tensor:\n",
    "        # assert len(encoder_inputs.shape) == 2 and encoder_inputs.shape[0] == 1\n",
    "        if encoder_inputs_mask is None:\n",
    "            encoder_inputs_mask = encoder_inputs.eq(self.pad_idx)\n",
    "        # 预测阶段，你通常只会逐步生成输出，而不需要像训练时那样批量地计算注意力。输入的是多长就是多长，不需要padding\n",
    "        encoder_inputs_mask = encoder_inputs_mask.unsqueeze(1).unsqueeze(\n",
    "            2\n",
    "        )  # [batch_size, 1, 1, src_len]\n",
    "        look_ahead_mask = self.generate_square_subsequent_mask(self.max_length)\n",
    "        look_ahead_mask = (\n",
    "            look_ahead_mask.unsqueeze(0).unsqueeze(0).to(encoder_inputs.device)\n",
    "        )  # [1, 1, trg_len, trg_len]\n",
    "\n",
    "        # encoding\n",
    "        encoder_inputs_embeds = self.src_embedding(encoder_inputs)\n",
    "        encoder_outputs = self.encoder(encoder_inputs_embeds)\n",
    "\n",
    "        # decoding\n",
    "        #预测时的look_ahead_mask可有可无，我们这里加不加都行\n",
    "        decoder_inputs = torch.Tensor([self.bos_idx] * encoder_inputs.shape[0]).reshape(-1, 1).long().to(device=encoder_inputs.device)\n",
    "        for cur_len in tqdm(range(1, self.max_length + 1)):\n",
    "            decoder_inputs_embeds = self.trg_embedding(decoder_inputs)\n",
    "            decoder_outputs = self.decoder(\n",
    "                decoder_inputs_embeds=decoder_inputs_embeds,\n",
    "                encoder_outputs=encoder_outputs.last_hidden_states,\n",
    "                attn_mask=look_ahead_mask[:, :, :cur_len, :cur_len],\n",
    "            )\n",
    "\n",
    "            logits = self.linear(decoder_outputs.last_hidden_states)\n",
    "            next_token = logits.argmax(dim=-1)[:, -1:]\n",
    "            decoder_inputs = torch.cat([decoder_inputs, next_token], dim=-1)\n",
    "\n",
    "            if all((decoder_inputs == self.eos_idx).sum(dim=-1) > 0):\n",
    "                break\n",
    "\n",
    "        return TransformerOutput(\n",
    "            preds=decoder_inputs[:, 1:],\n",
    "            logits=logits,\n",
    "            encoder_last_hidden_states=encoder_outputs.last_hidden_states,\n",
    "            encoder_attn_scores=encoder_outputs.attn_scores,\n",
    "            decoder_last_hidden_states=decoder_outputs.last_hidden_states,\n",
    "            decoder_self_attn_scores=decoder_outputs.self_attn_scores,\n",
    "            decoder_cross_attn_scores=decoder_outputs.cross_attn_scores,\n",
    "        )"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:06.466243Z",
     "iopub.execute_input": "2023-12-15T09:33:06.466548Z",
     "iopub.status.idle": "2023-12-15T09:33:06.492423Z",
     "shell.execute_reply.started": "2023-12-15T09:33:06.466522Z",
     "shell.execute_reply": "2023-12-15T09:33:06.491432Z"
    },
    "trusted": true
   },
   "execution_count": 32,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 训练"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 损失函数"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class CrossEntropyWithPadding:\n",
    "    def __init__(self, config):\n",
    "        self.label_smoothing = config[\"label_smoothing\"]\n",
    "        \n",
    "    def __call__(self, logits, labels, padding_mask=None):\n",
    "        # logits.shape = [batch size, sequence length, num of classes]\n",
    "        # labels.shape = [batch size, sequence length]\n",
    "        # padding_mask.shape = [batch size, sequence length]\n",
    "        bs, seq_len, nc = logits.shape\n",
    "        loss = F.cross_entropy(logits.reshape(bs * seq_len, nc), labels.reshape(-1), reduce=False, label_smoothing=self.label_smoothing)\n",
    "        if padding_mask is None:\n",
    "            loss = loss.mean()\n",
    "        else:\n",
    "            padding_mask = 1 - padding_mask.reshape(-1)\n",
    "            loss = torch.mul(loss, padding_mask).sum() / padding_mask.sum()\n",
    "        \n",
    "        return loss\n",
    "    "
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:06.493854Z",
     "iopub.execute_input": "2023-12-15T09:33:06.494555Z",
     "iopub.status.idle": "2023-12-15T09:33:06.505896Z",
     "shell.execute_reply.started": "2023-12-15T09:33:06.494516Z",
     "shell.execute_reply": "2023-12-15T09:33:06.505015Z"
    },
    "trusted": true
   },
   "execution_count": 33,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 学习率衰减"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class NoamDecayScheduler:\n",
    "    def __init__(self, config):\n",
    "        self.d_model = config[\"d_model\"]\n",
    "        self.warmup_steps = config[\"warmup_steps\"]\n",
    "        \n",
    "    def __call__(self, step):\n",
    "        step += 1\n",
    "        arg1 = step ** (-0.5)\n",
    "        arg2 = step * (self.warmup_steps ** (-1.5))\n",
    "        \n",
    "        arg3 = self.d_model ** (-0.5)\n",
    "        \n",
    "        return arg3 * np.minimum(arg1, arg2)\n",
    "    \n",
    "    \n",
    "temp_learning_rate_schedule = NoamDecayScheduler({\"d_model\": 512, \"warmup_steps\": 4000})\n",
    "#下面是学习率的设计图\n",
    "plt.plot(temp_learning_rate_schedule(np.arange(0, 40_000)))\n",
    "plt.ylabel(\"Leraning rate\")\n",
    "plt.xlabel(\"Train step\")\n",
    "plt.show()\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:06.507035Z",
     "iopub.execute_input": "2023-12-15T09:33:06.507340Z",
     "iopub.status.idle": "2023-12-15T09:33:06.810081Z",
     "shell.execute_reply.started": "2023-12-15T09:33:06.507304Z",
     "shell.execute_reply": "2023-12-15T09:33:06.808802Z"
    },
    "trusted": true
   },
   "execution_count": 34,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 优化器"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.optim.lr_scheduler import LambdaLR\n",
    "from torch.optim import Adam\n",
    "    \n",
    "def get_optimizer(model, config):\n",
    "    base_lr = 0.1\n",
    "    beta1 = config[\"beta1\"]\n",
    "    beta2 = config[\"beta2\"]\n",
    "    eps = config[\"eps\"]\n",
    "    optimizer = Adam(model.parameters(), lr=base_lr, betas=(beta1, beta2), eps=eps)\n",
    "    lr_scheduler = NoamDecayScheduler(config)\n",
    "    scheduler = LambdaLR(optimizer, lr_lambda=lr_scheduler)\n",
    "    return optimizer, scheduler"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:06.811970Z",
     "iopub.execute_input": "2023-12-15T09:33:06.812363Z",
     "iopub.status.idle": "2023-12-15T09:33:06.821245Z",
     "shell.execute_reply.started": "2023-12-15T09:33:06.812326Z",
     "shell.execute_reply": "2023-12-15T09:33:06.820087Z"
    },
    "trusted": true
   },
   "execution_count": 35,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Callback"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:06.822655Z",
     "iopub.execute_input": "2023-12-15T09:33:06.823226Z",
     "iopub.status.idle": "2023-12-15T09:33:16.997624Z",
     "shell.execute_reply.started": "2023-12-15T09:33:06.823199Z",
     "shell.execute_reply": "2023-12-15T09:33:16.996596Z"
    },
    "trusted": true
   },
   "execution_count": 36,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = - np.inf\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:16.999085Z",
     "iopub.execute_input": "2023-12-15T09:33:16.999945Z",
     "iopub.status.idle": "2023-12-15T09:33:17.009571Z",
     "shell.execute_reply.started": "2023-12-15T09:33:16.999905Z",
     "shell.execute_reply": "2023-12-15T09:33:17.008562Z"
    },
    "trusted": true
   },
   "execution_count": 37,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = - np.inf\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:17.010818Z",
     "iopub.execute_input": "2023-12-15T09:33:17.011372Z",
     "iopub.status.idle": "2023-12-15T09:33:17.055059Z",
     "shell.execute_reply.started": "2023-12-15T09:33:17.011345Z",
     "shell.execute_reply": "2023-12-15T09:33:17.053811Z"
    },
    "trusted": true
   },
   "execution_count": 38,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### training & valuating"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    for batch in dataloader:\n",
    "        encoder_inputs = batch[\"encoder_inputs\"]\n",
    "        encoder_inputs_mask = batch[\"encoder_inputs_mask\"]\n",
    "        decoder_inputs = batch[\"decoder_inputs\"]\n",
    "        decoder_labels = batch[\"decoder_labels\"]\n",
    "        decoder_labels_mask = batch[\"decoder_labels_mask\"]\n",
    "        \n",
    "        # 前向计算\n",
    "        outputs = model(\n",
    "            encoder_inputs=encoder_inputs, \n",
    "            decoder_inputs=decoder_inputs, \n",
    "            encoder_inputs_mask=encoder_inputs_mask\n",
    "            )\n",
    "        logits = outputs.logits\n",
    "        loss = loss_fct(logits, decoder_labels)         # 验证集损失\n",
    "        loss_list.append(loss.cpu().item())\n",
    "        \n",
    "    return np.mean(loss_list)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:17.056493Z",
     "iopub.execute_input": "2023-12-15T09:33:17.057322Z",
     "iopub.status.idle": "2023-12-15T09:33:17.067197Z",
     "shell.execute_reply.started": "2023-12-15T09:33:17.057276Z",
     "shell.execute_reply": "2023-12-15T09:33:17.066071Z"
    },
    "trusted": true
   },
   "execution_count": 39,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    scheduler=None,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 1\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for batch in train_loader:\n",
    "                encoder_inputs = batch[\"encoder_inputs\"]\n",
    "                encoder_inputs_mask = batch[\"encoder_inputs_mask\"]\n",
    "                decoder_inputs = batch[\"decoder_inputs\"]\n",
    "                decoder_labels = batch[\"decoder_labels\"]\n",
    "                \n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                \n",
    "                # 前向计算\n",
    "                outputs = model(\n",
    "                    encoder_inputs=encoder_inputs, \n",
    "                    decoder_inputs=decoder_inputs, \n",
    "                    encoder_inputs_mask=encoder_inputs_mask\n",
    "                    )\n",
    "                logits = outputs.logits\n",
    "                loss = loss_fct(logits, decoder_labels)\n",
    "                \n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                \n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                if scheduler is not None:\n",
    "                    scheduler.step()\n",
    "            \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    cur_lr = optimizer.param_groups[0][\"lr\"] if scheduler is None else scheduler.get_last_lr()[0]\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            lr=cur_lr,\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=-val_loss)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(-val_loss)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "            pbar.set_postfix({\"epoch\": epoch_id, \"loss\": loss, \"val_loss\": val_loss})\n",
    "        \n",
    "    return record_dict\n",
    "        "
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:17.068938Z",
     "iopub.execute_input": "2023-12-15T09:33:17.069586Z",
     "iopub.status.idle": "2023-12-15T09:33:17.089076Z",
     "shell.execute_reply.started": "2023-12-15T09:33:17.069557Z",
     "shell.execute_reply": "2023-12-15T09:33:17.085922Z"
    },
    "trusted": true
   },
   "execution_count": 40,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "config = {\n",
    "    \"bos_idx\": 1,\n",
    "    \"eos_idx\": 3,\n",
    "    \"pad_idx\": 0,\n",
    "    \"vocab_size\": len(word2idx),\n",
    "    \"max_length\": 128,\n",
    "    \"d_model\": 512, \n",
    "    \"dim_feedforward\": 2048, \n",
    "    \"dropout\": 0.1, \n",
    "    \"layer_norm_eps\": 1e-6, \n",
    "    \"num_heads\": 8, \n",
    "    \"num_decoder_layers\": 6,\n",
    "    \"num_encoder_layers\": 6,\n",
    "    \"label_smoothing\": 0.1,\n",
    "    \"beta1\": 0.9,\n",
    "    \"beta2\": 0.98,\n",
    "    \"eps\": 1e-9,\n",
    "    \"warmup_steps\": 4_000,\n",
    "    \"share_embedding\": True,\n",
    "    }\n",
    "\n",
    "\n",
    "def get_dl(dataset, batch_size, shuffle=True):\n",
    "    sampler = TransformerBatchSampler(dataset, batch_size=batch_size, shuffle_batch=shuffle)\n",
    "    sample_dl = DataLoader(dataset, batch_sampler=sampler, collate_fn=partial(collate_fct, tokenizer=tokenizer))\n",
    "    return sample_dl\n",
    "\n",
    "# dataset\n",
    "train_ds = LangPairDataset(\"train\", max_length=config[\"max_length\"])\n",
    "val_ds = LangPairDataset(\"val\", max_length=config[\"max_length\"])\n",
    "# tokenizer\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word, max_length=config[\"max_length\"])\n",
    "batch_size = 2048\n",
    "# dataloader\n",
    "train_dl = get_dl(train_ds, batch_size=batch_size, shuffle=True)\n",
    "val_dl = get_dl(val_ds, batch_size=batch_size, shuffle=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:17.090411Z",
     "iopub.execute_input": "2023-12-15T09:33:17.091178Z",
     "iopub.status.idle": "2023-12-15T09:33:17.549979Z",
     "shell.execute_reply.started": "2023-12-15T09:33:17.091142Z",
     "shell.execute_reply": "2023-12-15T09:33:17.548942Z"
    },
    "trusted": true
   },
   "execution_count": 41,
   "outputs": [
    {
     "name": "stdout",
     "text": "load train dataset from .cache/de2en_train_128.npy\nload val dataset from .cache/de2en_val_128.npy\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "epoch = 20\n",
    "\n",
    "# model\n",
    "model = TransformerModel(config)\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = CrossEntropyWithPadding(config)\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer, scheduler = get_optimizer(model, config)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "exp_name = \"translate-transformer-{}\".format(\"share\" if config[\"share_embedding\"] else \"not-share\")\n",
    "tensorboard_callback = TensorBoardCallback(f\"runs/{exp_name}\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\n",
    "    f\"checkpoints/{exp_name}\", save_step=500, save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=8)\n",
    "\n",
    "model = model.to(device)\n",
    "\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    val_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer,\n",
    "    scheduler,\n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500\n",
    "    )\n",
    "\n",
    "# Training took 3.5 days on 8 P100 GPUs\n",
    "# We trained the base models for a total of 100,000 steps or 12 hours. For our big models,(described on the bottom line of table 3), step time was 1.0 seconds. The big models were trained for 300,000 steps (3.5 days)."
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:33:17.551495Z",
     "iopub.execute_input": "2023-12-15T09:33:17.551925Z",
     "iopub.status.idle": "2023-12-15T09:52:07.009001Z",
     "shell.execute_reply.started": "2023-12-15T09:33:17.551888Z",
     "shell.execute_reply": "2023-12-15T09:52:07.007980Z"
    },
    "trusted": true
   },
   "execution_count": 42,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "  0%|          | 0/280 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0cbe717278b342c09e21a2b96792dd63"
      }
     },
     "metadata": {}
    },
    {
     "name": "stderr",
     "text": "/opt/conda/lib/python3.10/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='none' instead.\n  warnings.warn(warning.format(ret))\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 推理\n",
    "\n",
    "- 翻译项目的评估指标一般是BLEU4，感兴趣的同学自行了解并实现\n",
    "- 接下来进行翻译推理，并作出注意力的热度图"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "!ls checkpoints/translate-transformer-share"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T10:08:13.093543Z",
     "iopub.execute_input": "2023-12-15T10:08:13.094450Z",
     "iopub.status.idle": "2023-12-15T10:08:14.135785Z",
     "shell.execute_reply.started": "2023-12-15T10:08:13.094408Z",
     "shell.execute_reply": "2023-12-15T10:08:14.134348Z"
    },
    "trusted": true
   },
   "execution_count": 46,
   "outputs": [
    {
     "name": "stdout",
     "text": "best.ckpt\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "# !pip install Cython  # if failed to install fastBPE, try this line\n",
    "!pip install fastBPE"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T09:52:07.010851Z",
     "iopub.execute_input": "2023-12-15T09:52:07.011742Z",
     "iopub.status.idle": "2023-12-15T09:52:29.715389Z",
     "shell.execute_reply.started": "2023-12-15T09:52:07.011701Z",
     "shell.execute_reply": "2023-12-15T09:52:29.714205Z"
    },
    "trusted": true
   },
   "execution_count": 43,
   "outputs": [
    {
     "name": "stdout",
     "text": "Collecting fastBPE\n  Downloading fastBPE-0.1.0.tar.gz (35 kB)\n  Preparing metadata (setup.py) ... \u001B[?25ldone\n\u001B[?25hBuilding wheels for collected packages: fastBPE\n  Building wheel for fastBPE (setup.py) ... \u001B[?25ldone\n\u001B[?25h  Created wheel for fastBPE: filename=fastBPE-0.1.0-cp310-cp310-linux_x86_64.whl size=74025 sha256=403621b79cc2ffc0e7145f52d791521a289b592f70d7cdb4b46b8c8130b59380\n  Stored in directory: /root/.cache/pip/wheels/13/5d/b9/4b8897941ebc9e8c6cc3f3ffd3ea5115731754269205098754\nSuccessfully built fastBPE\nInstalling collected packages: fastBPE\nSuccessfully installed fastBPE-0.1.0\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "import torch\n",
    "\n",
    "state_dict = torch.load(f\"checkpoints/{exp_name}/best.ckpt\", map_location=\"cpu\")\n",
    "\n",
    "# checkpoint = torch.load(\"epoch125-step132426.ckpt\", map_location=\"cpu\")\n",
    "# state_dict = checkpoint[\"state_dict\"]\n",
    "\n",
    "# update keys by dropping `model`\n",
    "for key in list(state_dict):\n",
    "    state_dict[key.replace(\"model.\", \"\")] = state_dict.pop(key)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T10:09:18.058270Z",
     "iopub.execute_input": "2023-12-15T10:09:18.059169Z",
     "iopub.status.idle": "2023-12-15T10:09:18.203172Z",
     "shell.execute_reply.started": "2023-12-15T10:09:18.059126Z",
     "shell.execute_reply": "2023-12-15T10:09:18.201943Z"
    },
    "trusted": true
   },
   "execution_count": 48,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# load checkpoints\n",
    "model = TransformerModel(config)\n",
    "model.load_state_dict(state_dict)\n",
    "\n",
    "\n",
    "# from dataset import LangPairDataset\n",
    "test_ds = LangPairDataset(\"test\", max_length=128, data_dir=\"../input/wmt16-de-en\")\n",
    "test_dl = DataLoader(test_ds, batch_size=1, collate_fn=partial(collate_fct, tokenizer=tokenizer))\n",
    "\n",
    "model = model.to(device)\n",
    "model.eval()\n",
    "collect = {}\n",
    "loss_collect = []\n",
    "for idx, batch in tqdm(enumerate(test_dl)):\n",
    "    encoder_inputs = batch[\"encoder_inputs\"].to(device=device)\n",
    "    encoder_inputs_mask = batch[\"encoder_inputs_mask\"].to(device=device)\n",
    "    decoder_inputs = batch[\"decoder_inputs\"].to(device=device)\n",
    "    decoder_labels = batch[\"decoder_labels\"].to(device=device)\n",
    "    \n",
    "    # 前向计算\n",
    "    outputs = model(\n",
    "        encoder_inputs=encoder_inputs, \n",
    "        decoder_inputs=decoder_inputs, \n",
    "        encoder_inputs_mask=encoder_inputs_mask\n",
    "        )\n",
    "    loss = loss_fct(outputs.logits, decoder_labels)         # 验证集损失\n",
    "    # outputs = model.infer(encoder_inputs=encoder_inputs)\n",
    "    # print(outputs.logits.shape, decoder_labels.shape)\n",
    "    \n",
    "    # loss = loss_fct(outputs.logits[:, :decoder_labels.shape[1]], decoder_labels)         # 验证集损失\n",
    "    # preds = logits.argmax(dim=-1)\n",
    "    collect[idx] = {\"loss\": loss.item(), \"src_inputs\": encoder_inputs, \"trg_inputs\": decoder_inputs, \"mask\": encoder_inputs_mask, \"trg_labels\": decoder_labels, \"preds\": outputs.preds}\n",
    "    loss_collect.append(loss.item())\n",
    "    \n",
    "# sort collect by value\n",
    "collect = sorted(collect.items(), key=lambda x: x[1][\"loss\"])\n",
    "print(f\"testing loss: {np.array(loss_collect).mean()}\")"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T10:22:45.099231Z",
     "iopub.execute_input": "2023-12-15T10:22:45.099662Z",
     "iopub.status.idle": "2023-12-15T10:23:01.963008Z",
     "shell.execute_reply.started": "2023-12-15T10:22:45.099627Z",
     "shell.execute_reply": "2023-12-15T10:23:01.962059Z"
    },
    "trusted": true
   },
   "execution_count": 51,
   "outputs": [
    {
     "name": "stdout",
     "text": "save cache to .cache/de2en_test_128.npy\n",
     "output_type": "stream"
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "0it [00:00, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "ca9333fc49244fa1aa8533b9750ab72c"
      }
     },
     "metadata": {}
    },
    {
     "name": "stdout",
     "text": "testing loss: 3.2648377707510283\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "%pip install sacremoses "
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T10:23:36.532405Z",
     "iopub.execute_input": "2023-12-15T10:23:36.533299Z",
     "iopub.status.idle": "2023-12-15T10:23:49.303822Z",
     "shell.execute_reply.started": "2023-12-15T10:23:36.533264Z",
     "shell.execute_reply": "2023-12-15T10:23:49.302571Z"
    },
    "trusted": true
   },
   "execution_count": 53,
   "outputs": [
    {
     "name": "stdout",
     "text": "Collecting sacremoses\n  Obtaining dependency information for sacremoses from https://files.pythonhosted.org/packages/0b/f0/89ee2bc9da434bd78464f288fdb346bc2932f2ee80a90b2a4bbbac262c74/sacremoses-0.1.1-py3-none-any.whl.metadata\n  Downloading sacremoses-0.1.1-py3-none-any.whl.metadata (8.3 kB)\nRequirement already satisfied: regex in /opt/conda/lib/python3.10/site-packages (from sacremoses) (2023.8.8)\nRequirement already satisfied: click in /opt/conda/lib/python3.10/site-packages (from sacremoses) (8.1.7)\nRequirement already satisfied: joblib in /opt/conda/lib/python3.10/site-packages (from sacremoses) (1.3.2)\nRequirement already satisfied: tqdm in /opt/conda/lib/python3.10/site-packages (from sacremoses) (4.66.1)\nDownloading sacremoses-0.1.1-py3-none-any.whl (897 kB)\n\u001B[2K   \u001B[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001B[0m \u001B[32m897.5/897.5 kB\u001B[0m \u001B[31m40.5 MB/s\u001B[0m eta \u001B[36m0:00:00\u001B[0m\n\u001B[?25hInstalling collected packages: sacremoses\nSuccessfully installed sacremoses-0.1.1\nNote: you may need to restart the kernel to use updated packages.\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "import re\n",
    "from fastBPE import fastBPE\n",
    "from sacremoses import MosesDetokenizer, MosesTokenizer\n",
    "\n",
    "\n",
    "\n",
    "class Translator:\n",
    "    def __init__(self, model, src_tokenizer, trg_tokenizer):\n",
    "        self.bpe = fastBPE(\"../input/wmt16-de-en/bpe.10000\", \"../input/wmt16-de-en/vocab\")\n",
    "        self.mose_tokenizer = MosesTokenizer(lang=\"de\")\n",
    "        self.mose_detokenizer = MosesDetokenizer(lang=\"en\")\n",
    "        self.model = model\n",
    "        self.model.eval()\n",
    "        self.src_tokenizer = src_tokenizer\n",
    "        self.trg_tokenizer = trg_tokenizer\n",
    "        self.pattern = re.compile(r'(@@ )|(@@ ?$)')\n",
    "        \n",
    "    def draw_attention_map(self, attn_scores, cross_attn_scores, src_words_list, trg_words_list):\n",
    "        \"\"\"绘制注意力热力图\n",
    "        \n",
    "        Args:\n",
    "            - scores (numpy.ndarray): shape = [source sequence length, target sequence length]\n",
    "        \"\"\"\n",
    "        assert len(attn_scores.shape) == 3, \"attn_scores shape should be \" \\\n",
    "            f\"[num heads, target sequence length, target sequence length], but got {attn_scores.shape}\"\n",
    "        attn_scores = attn_scores[:, :len(trg_words_list), :len(trg_words_list)]\n",
    "        \n",
    "        assert len(cross_attn_scores.shape) == 3, \"attn_scores shape should be \" \\\n",
    "            f\"[num heads, target sequence length, source sequence length], but got {cross_attn_scores.shape}\"\n",
    "        cross_attn_scores = cross_attn_scores[:, :len(trg_words_list), :len(src_words_list)]\n",
    "        \n",
    "        num_heads, trg_len, src_len = cross_attn_scores.shape\n",
    "        \n",
    "        fig = plt.figure(figsize=(10, 5), constrained_layout=True)\n",
    "        grid = plt.GridSpec(trg_len, trg_len + src_len, wspace=0.1, hspace=0.1)\n",
    "        \n",
    "        self_map = fig.add_subplot(grid[:,:trg_len])\n",
    "        self_map.matshow(attn_scores.mean(dim=0), cmap='viridis')\n",
    "        self_map.set_yticks(range(trg_len), trg_words_list, fontsize=10)\n",
    "        self_map.set_xticks(range(trg_len), [\"[BOS]\"] + trg_words_list[:-1], rotation=90)\n",
    "        \n",
    "        cross_map = fig.add_subplot(grid[:, trg_len:])\n",
    "        cross_map.matshow(cross_attn_scores.mean(dim=0), cmap='viridis')\n",
    "        cross_map.set_yticks(range(trg_len), [], fontsize=6)\n",
    "        cross_map.set_xticks(range(src_len), src_words_list, rotation=90)\n",
    "        \n",
    "        plt.show()\n",
    "        \n",
    "    def draw_attention_maps(self, attn_scores, cross_attn_scores, src_words_list, trg_words_list, heads_list):\n",
    "        \"\"\"绘制注意力热力图\n",
    "        \n",
    "        Args:\n",
    "            - scores (numpy.ndarray): shape = [source sequence length, target sequence length]\n",
    "        \"\"\"\n",
    "        assert len(attn_scores.shape) == 3, \"attn_scores shape should be \" \\\n",
    "            f\"[num heads, target sequence length, target sequence length], but got {attn_scores.shape}\"\n",
    "        attn_scores = attn_scores[:, :len(trg_words_list), :len(trg_words_list)]\n",
    "        \n",
    "        assert len(cross_attn_scores.shape) == 3, \"attn_scores shape should be \" \\\n",
    "            f\"[num heads, target sequence length, source sequence length], but got {cross_attn_scores.shape}\"\n",
    "        cross_attn_scores = cross_attn_scores[:, :len(trg_words_list), :len(src_words_list)]\n",
    "        # cross_attn_scores = cross_attn_scores[:, :len(src_words_list), :len(src_words_list)]\n",
    "            \n",
    "        num_heads, trg_len, src_len = cross_attn_scores.shape\n",
    "        fig, axes = plt.subplots(2, len(heads_list), figsize=(5 * len(heads_list), 10))\n",
    "        for i, heads_idx in enumerate(heads_list):\n",
    "            axes[0, i].matshow(attn_scores[heads_idx], cmap='viridis')\n",
    "            axes[0, i].set_yticks(range(trg_len), trg_words_list)\n",
    "            axes[0, i].set_xticks(range(trg_len), [\"[BOS]\"] + trg_words_list[:-1], rotation=90)\n",
    "            axes[0, i].set_title(f\"head {heads_idx}\")\n",
    "            axes[1, i].matshow(cross_attn_scores[heads_idx], cmap='viridis')\n",
    "            axes[1, i].set_yticks(range(trg_len), trg_words_list)\n",
    "            axes[1, i].set_xticks(range(src_len), src_words_list, rotation=90)\n",
    "            axes[1, i].set_title(f\"head {heads_idx}\")\n",
    "            \n",
    "        plt.show()    \n",
    "    \n",
    "        \n",
    "    def __call__(self, sentence_list, heads_list=None, layer_idx=-1):\n",
    "        sentence_list = [\" \".join(self.mose_tokenizer.tokenize(s.lower())) for s in sentence_list]\n",
    "        tokens_list = [s.split() for s in self.bpe.apply(sentence_list)]\n",
    "        \n",
    "        encoder_input, attn_mask = self.src_tokenizer.encode(\n",
    "            tokens_list, \n",
    "            add_bos=True, \n",
    "            add_eos=True, \n",
    "            return_mask=True,\n",
    "            )\n",
    "        encoder_input = torch.Tensor(encoder_input).to(dtype=torch.int64)\n",
    "\n",
    "        outputs = model.infer(encoder_inputs=encoder_input, encoder_inputs_mask=attn_mask)\n",
    "        \n",
    "        preds = outputs.preds.numpy()\n",
    "        \n",
    "        trg_decoded = self.trg_tokenizer.decode(preds, split=True, remove_eos=False, remove_bos=False, remove_pad=False)\n",
    "        \n",
    "        src_decoded = self.src_tokenizer.decode(\n",
    "            encoder_input.numpy(), \n",
    "            split=True, \n",
    "            remove_bos=False, \n",
    "            remove_eos=False\n",
    "            )\n",
    "        \n",
    "        # post processed attn scores\n",
    "        # outputs.decoder_attentions[-1]  # the last layer of self-attention scores\n",
    "        \n",
    "        # draw the attention map of the last decoder block\n",
    "        for attn_score, cross_attn_score, src, trg in zip(\n",
    "            outputs.decoder_self_attn_scores[layer_idx], outputs.decoder_cross_attn_scores[layer_idx], src_decoded, trg_decoded):\n",
    "            if heads_list is None:\n",
    "                self.draw_attention_map(\n",
    "                    attn_score,\n",
    "                    cross_attn_score,\n",
    "                    src,\n",
    "                    trg,\n",
    "                )\n",
    "            else:\n",
    "                self.draw_attention_maps(\n",
    "                    attn_score,\n",
    "                    cross_attn_score,\n",
    "                    src,\n",
    "                    trg,\n",
    "                    heads_list=heads_list,\n",
    "                    )\n",
    "        return [self.mose_detokenizer.tokenize(self.pattern.sub(\"\", s).split()) for s in self.trg_tokenizer.decode(preds)]\n",
    "        \n",
    "        \n",
    "sentence_list = [\n",
    "    \"Mann in einem kleinen weißen Boot auf einem See.\",  # Man in a small white boat on a lake.\n",
    "    \"Ein Mann mit einem Eimer und ein Mädchen mit einem Hut am Strand.\", # A man with a bucket and a girl in a hat on the beach.\n",
    "    \"Drei Männer auf Pferden während eines Rennens.\",  # Three men on horses during a race.\n",
    "    \"Ein Mann und eine Frau essen zu Abend\",  # 一个男人和一个女人在吃晚餐\n",
    "]\n",
    "\n",
    "\n",
    "# load checkpoints\n",
    "model = TransformerModel(config)\n",
    "model.load_state_dict(state_dict)\n",
    "translator = Translator(model.cpu(), tokenizer, tokenizer)\n",
    "translator(\n",
    "    sentence_list,\n",
    "    layer_idx=-1,\n",
    "    # heads_list=[0, 1, 2, 3, 4, 5, 6, 7]\n",
    "    )\n",
    "    "
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-15T10:23:58.062344Z",
     "iopub.execute_input": "2023-12-15T10:23:58.062760Z",
     "iopub.status.idle": "2023-12-15T10:24:03.288133Z",
     "shell.execute_reply.started": "2023-12-15T10:23:58.062706Z",
     "shell.execute_reply": "2023-12-15T10:24:03.287000Z"
    },
    "trusted": true
   },
   "execution_count": 54,
   "outputs": [
    {
     "name": "stderr",
     "text": "Loading vocabulary from ../input/wmt16-de-en/vocab ...\nRead 798250 words (9714 unique) from vocabulary file.\nLoading codes from ../input/wmt16-de-en/bpe.10000 ...\nRead 10001 codes from the codes file.\n",
     "output_type": "stream"
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "  0%|          | 0/128 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "3e0043cf8aa741538e3b41089eee0aee"
      }
     },
     "metadata": {}
    },
    {
     "name": "stderr",
     "text": "/opt/conda/lib/python3.10/site-packages/IPython/core/pylabtools.py:152: UserWarning: There are no gridspecs with layoutgrids. Possibly did not call parent GridSpec with the \"figure\" keyword\n  fig.canvas.print_figure(bytes_io, **kw)\n",
     "output_type": "stream"
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "execution_count": 54,
     "output_type": "execute_result",
     "data": {
      "text/plain": "['man in white boat on a boat under a lake.',\n 'a man with a hat and a girl with a fishing net on a beach.',\n 'three men on horses watch a race race during a race.',\n 'a man and woman are enjoying a meal of food.']"
     },
     "metadata": {}
    }
   ]
  }
 ]
}
